!
    function(e) {
        if ("object" == typeof exports && "undefined" != typeof module) module.exports = e();
        else if ("function" == typeof define && define.amd) define([], e);
        else {
            var f;
            "undefined" != typeof window ? f = window: "undefined" != typeof global ? f = global: "undefined" != typeof self && (f = self),
                f.io = e()
        }
    } (function() {
        var define, module, exports;
        return function e(t, n, r) {
            function s(o, u) {
                if (!n[o]) {
                    if (!t[o]) {
                        var a = typeof require == "function" && require;
                        if (!u && a) return a(o, !0);
                        if (i) return i(o, !0);
                        throw new Error("Cannot find module '" + o + "'")
                    }
                    var f = n[o] = {
                        exports: {}
                    };
                    t[o][0].call(f.exports,
                        function(e) {
                            var n = t[o][1][e];
                            return s(n ? n: e)
                        },
                        f, f.exports, e, t, n, r)
                }
                return n[o].exports
            }
            var i = typeof require == "function" && require;
            for (var o = 0; o < r.length; o++) s(r[o]);
            return s
        } ({
                1 : [function(_dereq_, module, exports) {
                    module.exports = _dereq_("./lib/")
                },
                    {
                        "./lib/": 2
                    }],
                2 : [function(_dereq_, module, exports) {
                    var url = _dereq_("./url");
                    var parser = _dereq_("socket.io-parser");
                    var Manager = _dereq_("./manager");
                    var debug = _dereq_("debug")("socket.io-client");
                    module.exports = exports = lookup;
                    var cache = exports.managers = {};
                    function lookup(uri, opts) {
                        if (typeof uri == "object") {
                            opts = uri;
                            uri = undefined
                        }
                        opts = opts || {};
                        var parsed = url(uri);
                        var source = parsed.source;
                        var id = parsed.id;
                        var io;
                        if (opts.forceNew || opts["force new connection"] || false === opts.multiplex) {
                            debug("ignoring socket cache for %s", source);
                            io = Manager(source, opts)
                        } else {
                            if (!cache[id]) {
                                debug("new io instance for %s", source);
                                cache[id] = Manager(source, opts)
                            }
                            io = cache[id]
                        }
                        return io.socket(parsed.path)
                    }
                    exports.protocol = parser.protocol;
                    exports.connect = lookup;
                    exports.Manager = _dereq_("./manager");
                    exports.Socket = _dereq_("./socket")
                },
                    {
                        "./manager": 3,
                        "./socket": 5,
                        "./url": 6,
                        debug: 10,
                        "socket.io-parser": 46
                    }],
                3 : [function(_dereq_, module, exports) {
                    var url = _dereq_("./url");
                    var eio = _dereq_("engine.io-client");
                    var Socket = _dereq_("./socket");
                    var Emitter = _dereq_("component-emitter");
                    var parser = _dereq_("socket.io-parser");
                    var on = _dereq_("./on");
                    var bind = _dereq_("component-bind");
                    var object = _dereq_("object-component");
                    var debug = _dereq_("debug")("socket.io-client:manager");
                    var indexOf = _dereq_("indexof");
                    var Backoff = _dereq_("backo2");
                    module.exports = Manager;
                    function Manager(uri, opts) {
                        if (! (this instanceof Manager)) return new Manager(uri, opts);
                        if (uri && "object" == typeof uri) {
                            opts = uri;
                            uri = undefined
                        }
                        opts = opts || {};
                        opts.path = opts.path || "/socket.io";
                        this.nsps = {};
                        this.subs = [];
                        this.opts = opts;
                        this.reconnection(opts.reconnection !== false);
                        this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
                        this.reconnectionDelay(opts.reconnectionDelay || 1e3);
                        this.reconnectionDelayMax(opts.reconnectionDelayMax || 5e3);
                        this.randomizationFactor(opts.randomizationFactor || .5);
                        this.backoff = new Backoff({
                            min: this.reconnectionDelay(),
                            max: this.reconnectionDelayMax(),
                            jitter: this.randomizationFactor()
                        });
                        this.timeout(null == opts.timeout ? 2e4: opts.timeout);
                        this.readyState = "closed";
                        this.uri = uri;
                        this.connected = [];
                        this.encoding = false;
                        this.packetBuffer = [];
                        this.encoder = new parser.Encoder;
                        this.decoder = new parser.Decoder;
                        this.autoConnect = opts.autoConnect !== false;
                        if (this.autoConnect) this.open()
                    }
                    Manager.prototype.emitAll = function() {
                        this.emit.apply(this, arguments);
                        for (var nsp in this.nsps) {
                            this.nsps[nsp].emit.apply(this.nsps[nsp], arguments)
                        }
                    };
                    Manager.prototype.updateSocketIds = function() {
                        for (var nsp in this.nsps) {
                            this.nsps[nsp].id = this.engine.id
                        }
                    };
                    Emitter(Manager.prototype);
                    Manager.prototype.reconnection = function(v) {
                        if (!arguments.length) return this._reconnection;
                        this._reconnection = !!v;
                        return this
                    };
                    Manager.prototype.reconnectionAttempts = function(v) {
                        if (!arguments.length) return this._reconnectionAttempts;
                        this._reconnectionAttempts = v;
                        return this
                    };
                    Manager.prototype.reconnectionDelay = function(v) {
                        if (!arguments.length) return this._reconnectionDelay;
                        this._reconnectionDelay = v;
                        this.backoff && this.backoff.setMin(v);
                        return this
                    };
                    Manager.prototype.randomizationFactor = function(v) {
                        if (!arguments.length) return this._randomizationFactor;
                        this._randomizationFactor = v;
                        this.backoff && this.backoff.setJitter(v);
                        return this
                    };
                    Manager.prototype.reconnectionDelayMax = function(v) {
                        if (!arguments.length) return this._reconnectionDelayMax;
                        this._reconnectionDelayMax = v;
                        this.backoff && this.backoff.setMax(v);
                        return this
                    };
                    Manager.prototype.timeout = function(v) {
                        if (!arguments.length) return this._timeout;
                        this._timeout = v;
                        return this
                    };
                    Manager.prototype.maybeReconnectOnOpen = function() {
                        if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {
                            this.reconnect()
                        }
                    };
                    Manager.prototype.open = Manager.prototype.connect = function(fn) {
                        debug("readyState %s", this.readyState);
                        if (~this.readyState.indexOf("open")) return this;
                        debug("opening %s", this.uri);
                        this.engine = eio(this.uri, this.opts);
                        var socket = this.engine;
                        var self = this;
                        this.readyState = "opening";
                        this.skipReconnect = false;
                        var openSub = on(socket, "open",
                            function() {
                                self.onopen();
                                fn && fn()
                            });
                        var errorSub = on(socket, "error",
                            function(data) {
                                debug("connect_error");
                                self.cleanup();
                                self.readyState = "closed";
                                self.emitAll("connect_error", data);
                                if (fn) {
                                    var err = new Error("Connection error");
                                    err.data = data;
                                    fn(err)
                                } else {
                                    self.maybeReconnectOnOpen()
                                }
                            });
                        if (false !== this._timeout) {
                            var timeout = this._timeout;
                            debug("connect attempt will timeout after %d", timeout);
                            var timer = setTimeout(function() {
                                    debug("connect attempt timed out after %d", timeout);
                                    openSub.destroy();
                                    socket.close();
                                    socket.emit("error", "timeout");
                                    self.emitAll("connect_timeout", timeout)
                                },
                                timeout);
                            this.subs.push({
                                destroy: function() {
                                    clearTimeout(timer)
                                }
                            })
                        }
                        this.subs.push(openSub);
                        this.subs.push(errorSub);
                        return this
                    };
                    Manager.prototype.onopen = function() {
                        debug("open");
                        this.cleanup();
                        this.readyState = "open";
                        this.emit("open");
                        var socket = this.engine;
                        this.subs.push(on(socket, "data", bind(this, "ondata")));
                        this.subs.push(on(this.decoder, "decoded", bind(this, "ondecoded")));
                        this.subs.push(on(socket, "error", bind(this, "onerror")));
                        this.subs.push(on(socket, "close", bind(this, "onclose")))
                    };
                    Manager.prototype.ondata = function(data) {
                        this.decoder.add(data)
                    };
                    Manager.prototype.ondecoded = function(packet) {
                        this.emit("packet", packet)
                    };
                    Manager.prototype.onerror = function(err) {
                        debug("error", err);
                        this.emitAll("error", err)
                    };
                    Manager.prototype.socket = function(nsp) {
                        var socket = this.nsps[nsp];
                        if (!socket) {
                            socket = new Socket(this, nsp);
                            this.nsps[nsp] = socket;
                            var self = this;
                            socket.on("connect",
                                function() {
                                    socket.id = self.engine.id;
                                    if (!~indexOf(self.connected, socket)) {
                                        self.connected.push(socket)
                                    }
                                })
                        }
                        return socket
                    };
                    Manager.prototype.destroy = function(socket) {
                        var index = indexOf(this.connected, socket);
                        if (~index) this.connected.splice(index, 1);
                        if (this.connected.length) return;
                        this.close()
                    };
                    Manager.prototype.packet = function(packet) {
                        debug("writing packet %j", packet);
                        var self = this;
                        if (!self.encoding) {
                            self.encoding = true;
                            this.encoder.encode(packet,
                                function(encodedPackets) {
                                    for (var i = 0; i < encodedPackets.length; i++) {
                                        self.engine.write(encodedPackets[i])
                                    }
                                    self.encoding = false;
                                    self.processPacketQueue()
                                })
                        } else {
                            self.packetBuffer.push(packet)
                        }
                    };
                    Manager.prototype.processPacketQueue = function() {
                        if (this.packetBuffer.length > 0 && !this.encoding) {
                            var pack = this.packetBuffer.shift();
                            this.packet(pack)
                        }
                    };
                    Manager.prototype.cleanup = function() {
                        var sub;
                        while (sub = this.subs.shift()) sub.destroy();
                        this.packetBuffer = [];
                        this.encoding = false;
                        this.decoder.destroy()
                    };
                    Manager.prototype.close = Manager.prototype.disconnect = function() {
                        this.skipReconnect = true;
                        this.backoff.reset();
                        this.readyState = "closed";
                        this.engine && this.engine.close()
                    };
                    Manager.prototype.onclose = function(reason) {
                        debug("close");
                        this.cleanup();
                        this.backoff.reset();
                        this.readyState = "closed";
                        this.emit("close", reason);
                        if (this._reconnection && !this.skipReconnect) {
                            this.reconnect()
                        }
                    };
                    Manager.prototype.reconnect = function() {
                        if (this.reconnecting || this.skipReconnect) return this;
                        var self = this;
                        if (this.backoff.attempts >= this._reconnectionAttempts) {
                            debug("reconnect failed");
                            this.backoff.reset();
                            this.emitAll("reconnect_failed");
                            this.reconnecting = false
                        } else {
                            var delay = this.backoff.duration();
                            debug("will wait %dms before reconnect attempt", delay);
                            this.reconnecting = true;
                            var timer = setTimeout(function() {
                                    if (self.skipReconnect) return;
                                    debug("attempting reconnect");
                                    self.emitAll("reconnect_attempt", self.backoff.attempts);
                                    self.emitAll("reconnecting", self.backoff.attempts);
                                    if (self.skipReconnect) return;
                                    self.open(function(err) {
                                        if (err) {
                                            debug("reconnect attempt error");
                                            self.reconnecting = false;
                                            self.reconnect();
                                            self.emitAll("reconnect_error", err.data)
                                        } else {
                                            debug("reconnect success");
                                            self.onreconnect()
                                        }
                                    })
                                },
                                delay);
                            this.subs.push({
                                destroy: function() {
                                    clearTimeout(timer)
                                }
                            })
                        }
                    };
                    Manager.prototype.onreconnect = function() {
                        var attempt = this.backoff.attempts;
                        this.reconnecting = false;
                        this.backoff.reset();
                        this.updateSocketIds();
                        this.emitAll("reconnect", attempt)
                    }
                },
                    {
                        "./on": 4,
                        "./socket": 5,
                        "./url": 6,
                        backo2: 7,
                        "component-bind": 8,
                        "component-emitter": 9,
                        debug: 10,
                        "engine.io-client": 11,
                        indexof: 42,
                        "object-component": 43,
                        "socket.io-parser": 46
                    }],
                4 : [function(_dereq_, module, exports) {
                    module.exports = on;
                    function on(obj, ev, fn) {
                        obj.on(ev, fn);
                        return {
                            destroy: function() {
                                obj.removeListener(ev, fn)
                            }
                        }
                    }
                },
                    {}],
                5 : [function(_dereq_, module, exports) {
                    var parser = _dereq_("socket.io-parser");
                    var Emitter = _dereq_("component-emitter");
                    var toArray = _dereq_("to-array");
                    var on = _dereq_("./on");
                    var bind = _dereq_("component-bind");
                    var debug = _dereq_("debug")("socket.io-client:socket");
                    var hasBin = _dereq_("has-binary");
                    module.exports = exports = Socket;
                    var events = {
                        connect: 1,
                        connect_error: 1,
                        connect_timeout: 1,
                        disconnect: 1,
                        error: 1,
                        reconnect: 1,
                        reconnect_attempt: 1,
                        reconnect_failed: 1,
                        reconnect_error: 1,
                        reconnecting: 1
                    };
                    var emit = Emitter.prototype.emit;
                    function Socket(io, nsp) {
                        this.io = io;
                        this.nsp = nsp;
                        this.json = this;
                        this.ids = 0;
                        this.acks = {};
                        if (this.io.autoConnect) this.open();
                        this.receiveBuffer = [];
                        this.sendBuffer = [];
                        this.connected = false;
                        this.disconnected = true
                    }
                    Emitter(Socket.prototype);
                    Socket.prototype.subEvents = function() {
                        if (this.subs) return;
                        var io = this.io;
                        this.subs = [on(io, "open", bind(this, "onopen")), on(io, "packet", bind(this, "onpacket")), on(io, "close", bind(this, "onclose"))]
                    };
                    Socket.prototype.open = Socket.prototype.connect = function() {
                        if (this.connected) return this;
                        this.subEvents();
                        this.io.open();
                        if ("open" == this.io.readyState) this.onopen();
                        return this
                    };
                    Socket.prototype.send = function() {
                        var args = toArray(arguments);
                        args.unshift("message");
                        this.emit.apply(this, args);
                        return this
                    };
                    Socket.prototype.emit = function(ev) {
                        if (events.hasOwnProperty(ev)) {
                            emit.apply(this, arguments);
                            return this
                        }
                        var args = toArray(arguments);
                        var parserType = parser.EVENT;
                        if (hasBin(args)) {
                            parserType = parser.BINARY_EVENT
                        }
                        var packet = {
                            type: parserType,
                            data: args
                        };
                        if ("function" == typeof args[args.length - 1]) {
                            debug("emitting packet with ack id %d", this.ids);
                            this.acks[this.ids] = args.pop();
                            packet.id = this.ids++
                        }
                        if (this.connected) {
                            this.packet(packet)
                        } else {
                            this.sendBuffer.push(packet)
                        }
                        return this
                    };
                    Socket.prototype.packet = function(packet) {
                        packet.nsp = this.nsp;
                        this.io.packet(packet)
                    };
                    Socket.prototype.onopen = function() {
                        debug("transport is open - connecting");
                        if ("/" != this.nsp) {
                            this.packet({
                                type: parser.CONNECT
                            })
                        }
                    };
                    Socket.prototype.onclose = function(reason) {
                        debug("close (%s)", reason);
                        this.connected = false;
                        this.disconnected = true;
                        delete this.id;
                        this.emit("disconnect", reason)
                    };
                    Socket.prototype.onpacket = function(packet) {
                        if (packet.nsp != this.nsp) return;
                        switch (packet.type) {
                            case parser.CONNECT:
                                this.onconnect();
                                break;
                            case parser.EVENT:
                                this.onevent(packet);
                                break;
                            case parser.BINARY_EVENT:
                                this.onevent(packet);
                                break;
                            case parser.ACK:
                                this.onack(packet);
                                break;
                            case parser.BINARY_ACK:
                                this.onack(packet);
                                break;
                            case parser.DISCONNECT:
                                this.ondisconnect();
                                break;
                            case parser.ERROR:
                                this.emit("error", packet.data);
                                break
                        }
                    };
                    Socket.prototype.onevent = function(packet) {
                        var args = packet.data || [];
                        debug("emitting event %j", args);
                        if (null != packet.id) {
                            debug("attaching ack callback to event");
                            args.push(this.ack(packet.id))
                        }
                        if (this.connected) {
                            emit.apply(this, args)
                        } else {
                            this.receiveBuffer.push(args)
                        }
                    };
                    Socket.prototype.ack = function(id) {
                        var self = this;
                        var sent = false;
                        return function() {
                            if (sent) return;
                            sent = true;
                            var args = toArray(arguments);
                            debug("sending ack %j", args);
                            var type = hasBin(args) ? parser.BINARY_ACK: parser.ACK;
                            self.packet({
                                type: type,
                                id: id,
                                data: args
                            })
                        }
                    };
                    Socket.prototype.onack = function(packet) {
                        debug("calling ack %s with %j", packet.id, packet.data);
                        var fn = this.acks[packet.id];
                        fn.apply(this, packet.data);
                        delete this.acks[packet.id]
                    };
                    Socket.prototype.onconnect = function() {
                        this.connected = true;
                        this.disconnected = false;
                        this.emit("connect");
                        this.emitBuffered()
                    };
                    Socket.prototype.emitBuffered = function() {
                        var i;
                        for (i = 0; i < this.receiveBuffer.length; i++) {
                            emit.apply(this, this.receiveBuffer[i])
                        }
                        this.receiveBuffer = [];
                        for (i = 0; i < this.sendBuffer.length; i++) {
                            this.packet(this.sendBuffer[i])
                        }
                        this.sendBuffer = []
                    };
                    Socket.prototype.ondisconnect = function() {
                        debug("server disconnect (%s)", this.nsp);
                        this.destroy();
                        this.onclose("io server disconnect")
                    };
                    Socket.prototype.destroy = function() {
                        if (this.subs) {
                            for (var i = 0; i < this.subs.length; i++) {
                                this.subs[i].destroy()
                            }
                            this.subs = null
                        }
                        this.io.destroy(this)
                    };
                    Socket.prototype.close = Socket.prototype.disconnect = function() {
                        if (this.connected) {
                            debug("performing disconnect (%s)", this.nsp);
                            this.packet({
                                type: parser.DISCONNECT
                            })
                        }
                        this.destroy();
                        if (this.connected) {
                            this.onclose("io client disconnect")
                        }
                        return this
                    }
                },
                    {
                        "./on": 4,
                        "component-bind": 8,
                        "component-emitter": 9,
                        debug: 10,
                        "has-binary": 38,
                        "socket.io-parser": 46,
                        "to-array": 50
                    }],
                6 : [function(_dereq_, module, exports) { (function(global) {
                    var parseuri = _dereq_("parseuri");
                    var debug = _dereq_("debug")("socket.io-client:url");
                    module.exports = url;
                    function url(uri, loc) {
                        var obj = uri;
                        var loc = loc || global.location;
                        if (null == uri) uri = loc.protocol + "//" + loc.host;
                        if ("string" == typeof uri) {
                            if ("/" == uri.charAt(0)) {
                                if ("/" == uri.charAt(1)) {
                                    uri = loc.protocol + uri
                                } else {
                                    uri = loc.hostname + uri
                                }
                            }
                            if (!/^(https?|wss?):\/\//.test(uri)) {
                                debug("protocol-less url %s", uri);
                                if ("undefined" != typeof loc) {
                                    uri = loc.protocol + "//" + uri
                                } else {
                                    uri = "https://" + uri
                                }
                            }
                            debug("parse %s", uri);
                            obj = parseuri(uri)
                        }
                        if (!obj.port) {
                            if (/^(http|ws)$/.test(obj.protocol)) {
                                obj.port = "80"
                            } else if (/^(http|ws)s$/.test(obj.protocol)) {
                                obj.port = "443"
                            }
                        }
                        obj.path = obj.path || "/";
                        obj.id = obj.protocol + "://" + obj.host + ":" + obj.port;
                        obj.href = obj.protocol + "://" + obj.host + (loc && loc.port == obj.port ? "": ":" + obj.port);
                        return obj
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        debug: 10,
                        parseuri: 44
                    }],
                7 : [function(_dereq_, module, exports) {
                    module.exports = Backoff;
                    function Backoff(opts) {
                        opts = opts || {};
                        this.ms = opts.min || 100;
                        this.max = opts.max || 1e4;
                        this.factor = opts.factor || 2;
                        this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter: 0;
                        this.attempts = 0
                    }
                    Backoff.prototype.duration = function() {
                        var ms = this.ms * Math.pow(this.factor, this.attempts++);
                        if (this.jitter) {
                            var rand = Math.random();
                            var deviation = Math.floor(rand * this.jitter * ms);
                            ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation: ms + deviation
                        }
                        return Math.min(ms, this.max) | 0
                    };
                    Backoff.prototype.reset = function() {
                        this.attempts = 0
                    };
                    Backoff.prototype.setMin = function(min) {
                        this.ms = min
                    };
                    Backoff.prototype.setMax = function(max) {
                        this.max = max
                    };
                    Backoff.prototype.setJitter = function(jitter) {
                        this.jitter = jitter
                    }
                },
                    {}],
                8 : [function(_dereq_, module, exports) {
                    var slice = [].slice;
                    module.exports = function(obj, fn) {
                        if ("string" == typeof fn) fn = obj[fn];
                        if ("function" != typeof fn) throw new Error("bind() requires a function");
                        var args = slice.call(arguments, 2);
                        return function() {
                            return fn.apply(obj, args.concat(slice.call(arguments)))
                        }
                    }
                },
                    {}],
                9 : [function(_dereq_, module, exports) {
                    module.exports = Emitter;
                    function Emitter(obj) {
                        if (obj) return mixin(obj)
                    }
                    function mixin(obj) {
                        for (var key in Emitter.prototype) {
                            obj[key] = Emitter.prototype[key]
                        }
                        return obj
                    }
                    Emitter.prototype.on = Emitter.prototype.addEventListener = function(event, fn) {
                        this._callbacks = this._callbacks || {}; (this._callbacks[event] = this._callbacks[event] || []).push(fn);
                        return this
                    };
                    Emitter.prototype.once = function(event, fn) {
                        var self = this;
                        this._callbacks = this._callbacks || {};
                        function on() {
                            self.off(event, on);
                            fn.apply(this, arguments)
                        }
                        on.fn = fn;
                        this.on(event, on);
                        return this
                    };
                    Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function(event, fn) {
                        this._callbacks = this._callbacks || {};
                        if (0 == arguments.length) {
                            this._callbacks = {};
                            return this
                        }
                        var callbacks = this._callbacks[event];
                        if (!callbacks) return this;
                        if (1 == arguments.length) {
                            delete this._callbacks[event];
                            return this
                        }
                        var cb;
                        for (var i = 0; i < callbacks.length; i++) {
                            cb = callbacks[i];
                            if (cb === fn || cb.fn === fn) {
                                callbacks.splice(i, 1);
                                break
                            }
                        }
                        return this
                    };
                    Emitter.prototype.emit = function(event) {
                        this._callbacks = this._callbacks || {};
                        var args = [].slice.call(arguments, 1),
                            callbacks = this._callbacks[event];
                        if (callbacks) {
                            callbacks = callbacks.slice(0);
                            for (var i = 0,
                                     len = callbacks.length; i < len; ++i) {
                                callbacks[i].apply(this, args)
                            }
                        }
                        return this
                    };
                    Emitter.prototype.listeners = function(event) {
                        this._callbacks = this._callbacks || {};
                        return this._callbacks[event] || []
                    };
                    Emitter.prototype.hasListeners = function(event) {
                        return !! this.listeners(event).length
                    }
                },
                    {}],
                10 : [function(_dereq_, module, exports) {
                    module.exports = debug;
                    function debug(name) {
                        if (!debug.enabled(name)) return function() {};
                        return function(fmt) {
                            fmt = coerce(fmt);
                            var curr = new Date;
                            var ms = curr - (debug[name] || curr);
                            debug[name] = curr;
                            fmt = name + " " + fmt + " +" + debug.humanize(ms);
                            window.console && console.log && Function.prototype.apply.call(console.log, console, arguments)
                        }
                    }
                    debug.names = [];
                    debug.skips = [];
                    debug.enable = function(name) {
                        try {
                            localStorage.debug = name
                        } catch(e) {}
                        var split = (name || "").split(/[\s,]+/),
                            len = split.length;
                        for (var i = 0; i < len; i++) {
                            name = split[i].replace("*", ".*?");
                            if (name[0] === "-") {
                                debug.skips.push(new RegExp("^" + name.substr(1) + "$"))
                            } else {
                                debug.names.push(new RegExp("^" + name + "$"))
                            }
                        }
                    };
                    debug.disable = function() {
                        debug.enable("")
                    };
                    debug.humanize = function(ms) {
                        var sec = 1e3,
                            min = 60 * 1e3,
                            hour = 60 * min;
                        if (ms >= hour) return (ms / hour).toFixed(1) + "h";
                        if (ms >= min) return (ms / min).toFixed(1) + "m";
                        if (ms >= sec) return (ms / sec | 0) + "s";
                        return ms + "ms"
                    };
                    debug.enabled = function(name) {
                        for (var i = 0,
                                 len = debug.skips.length; i < len; i++) {
                            if (debug.skips[i].test(name)) {
                                return false
                            }
                        }
                        for (var i = 0,
                                 len = debug.names.length; i < len; i++) {
                            if (debug.names[i].test(name)) {
                                return true
                            }
                        }
                        return false
                    };
                    function coerce(val) {
                        if (val instanceof Error) return val.stack || val.message;
                        return val
                    }
                    try {
                        if (window.localStorage) debug.enable(localStorage.debug)
                    } catch(e) {}
                },
                    {}],
                11 : [function(_dereq_, module, exports) {
                    module.exports = _dereq_("./lib/")
                },
                    {
                        "./lib/": 12
                    }],
                12 : [function(_dereq_, module, exports) {
                    module.exports = _dereq_("./socket");
                    module.exports.parser = _dereq_("engine.io-parser")
                },
                    {
                        "./socket": 13,
                        "engine.io-parser": 25
                    }],
                13 : [function(_dereq_, module, exports) { (function(global) {
                    var transports = _dereq_("./transports");
                    var Emitter = _dereq_("component-emitter");
                    var debug = _dereq_("debug")("engine.io-client:socket");
                    var index = _dereq_("indexof");
                    var parser = _dereq_("engine.io-parser");
                    var parseuri = _dereq_("parseuri");
                    var parsejson = _dereq_("parsejson");
                    var parseqs = _dereq_("parseqs");
                    module.exports = Socket;
                    function noop() {}
                    function Socket(uri, opts) {
                        if (! (this instanceof Socket)) return new Socket(uri, opts);
                        opts = opts || {};
                        if (uri && "object" == typeof uri) {
                            opts = uri;
                            uri = null
                        }
                        if (uri) {
                            uri = parseuri(uri);
                            opts.host = uri.host;
                            opts.secure = uri.protocol == "https" || uri.protocol == "wss";
                            opts.port = uri.port;
                            if (uri.query) opts.query = uri.query
                        }
                        this.secure = null != opts.secure ? opts.secure: global.location && "https:" == location.protocol;
                        if (opts.host) {
                            var pieces = opts.host.split(":");
                            opts.hostname = pieces.shift();
                            if (pieces.length) {
                                opts.port = pieces.pop()
                            } else if (!opts.port) {
                                opts.port = this.secure ? "443": "80"
                            }
                        }
                        this.agent = opts.agent || false;
                        this.hostname = opts.hostname || (global.location ? location.hostname: "localhost");
                        this.port = opts.port || (global.location && location.port ? location.port: this.secure ? 443 : 80);
                        this.query = opts.query || {};
                        if ("string" == typeof this.query) this.query = parseqs.decode(this.query);
                        this.upgrade = false !== opts.upgrade;
                        this.path = (opts.path || "/engine.io").replace(/\/$/, "") + "/";
                        this.forceJSONP = !!opts.forceJSONP;
                        this.jsonp = false !== opts.jsonp;
                        this.forceBase64 = !!opts.forceBase64;
                        this.enablesXDR = !!opts.enablesXDR;
                        this.timestampParam = opts.timestampParam || "t";
                        this.timestampRequests = opts.timestampRequests;
                        this.transports = opts.transports || ["polling", "websocket"];
                        this.readyState = "";
                        this.writeBuffer = [];
                        this.callbackBuffer = [];
                        this.policyPort = opts.policyPort || 843;
                        this.rememberUpgrade = opts.rememberUpgrade || false;
                        this.binaryType = null;
                        this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;
                        this.perMessageDeflate = false !== opts.perMessageDeflate ? opts.perMessageDeflate || true: false;
                        this.pfx = opts.pfx || null;
                        this.key = opts.key || null;
                        this.passphrase = opts.passphrase || null;
                        this.cert = opts.cert || null;
                        this.ca = opts.ca || null;
                        this.ciphers = opts.ciphers || null;
                        this.rejectUnauthorized = opts.rejectUnauthorized || null;
                        this.open()
                    }
                    Socket.priorWebsocketSuccess = false;
                    Emitter(Socket.prototype);
                    Socket.protocol = parser.protocol;
                    Socket.Socket = Socket;
                    Socket.Transport = _dereq_("./transport");
                    Socket.transports = _dereq_("./transports");
                    Socket.parser = _dereq_("engine.io-parser");
                    Socket.prototype.createTransport = function(name) {
                        debug('creating transport "%s"', name);
                        var query = clone(this.query);
                        query.EIO = parser.protocol;
                        query.transport = name;
                        if (this.id) query.sid = this.id;
                        var transport = new transports[name]({
                            agent: this.agent,
                            hostname: this.hostname,
                            port: this.port,
                            secure: this.secure,
                            path: this.path,
                            query: query,
                            forceJSONP: this.forceJSONP,
                            jsonp: this.jsonp,
                            forceBase64: this.forceBase64,
                            enablesXDR: this.enablesXDR,
                            timestampRequests: this.timestampRequests,
                            timestampParam: this.timestampParam,
                            policyPort: this.policyPort,
                            socket: this,
                            pfx: this.pfx,
                            key: this.key,
                            passphrase: this.passphrase,
                            cert: this.cert,
                            ca: this.ca,
                            ciphers: this.ciphers,
                            rejectUnauthorized: this.rejectUnauthorized,
                            perMessageDeflate: this.perMessageDeflate
                        });
                        return transport
                    };
                    function clone(obj) {
                        var o = {};
                        for (var i in obj) {
                            if (obj.hasOwnProperty(i)) {
                                o[i] = obj[i]
                            }
                        }
                        return o
                    }
                    Socket.prototype.open = function() {
                        var transport;
                        if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") != -1) {
                            transport = "websocket"
                        } else if (0 == this.transports.length) {
                            var self = this;
                            setTimeout(function() {
                                    self.emit("error", "No transports available")
                                },
                                0);
                            return
                        } else {
                            transport = this.transports[0]
                        }
                        this.readyState = "opening";
                        var transport;
                        try {
                            transport = this.createTransport(transport)
                        } catch(e) {
                            this.transports.shift();
                            this.open();
                            return
                        }
                        transport.open();
                        this.setTransport(transport)
                    };
                    Socket.prototype.setTransport = function(transport) {
                        debug("setting transport %s", transport.name);
                        var self = this;
                        if (this.transport) {
                            debug("clearing existing transport %s", this.transport.name);
                            this.transport.removeAllListeners()
                        }
                        this.transport = transport;
                        transport.on("drain",
                            function() {
                                self.onDrain()
                            }).on("packet",
                            function(packet) {
                                self.onPacket(packet)
                            }).on("error",
                            function(e) {
                                self.onError(e)
                            }).on("close",
                            function() {
                                self.onClose("transport close")
                            })
                    };
                    Socket.prototype.probe = function(name) {
                        debug('probing transport "%s"', name);
                        var transport = this.createTransport(name, {
                                probe: 1
                            }),
                            failed = false,
                            self = this;
                        Socket.priorWebsocketSuccess = false;
                        function onTransportOpen() {
                            if (self.onlyBinaryUpgrades) {
                                var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;
                                failed = failed || upgradeLosesBinary
                            }
                            if (failed) return;
                            debug('probe transport "%s" opened', name);
                            transport.send([{
                                type: "ping",
                                data: "probe",
                                options: {
                                    compress: true
                                }
                            }]);
                            transport.once("packet",
                                function(msg) {
                                    if (failed) return;
                                    if ("pong" == msg.type && "probe" == msg.data) {
                                        debug('probe transport "%s" pong', name);
                                        self.upgrading = true;
                                        self.emit("upgrading", transport);
                                        if (!transport) return;
                                        Socket.priorWebsocketSuccess = "websocket" == transport.name;
                                        debug('pausing current transport "%s"', self.transport.name);
                                        self.transport.pause(function() {
                                            if (failed) return;
                                            if ("closed" == self.readyState) return;
                                            debug("changing transport and sending upgrade packet");
                                            cleanup();
                                            self.setTransport(transport);
                                            transport.send([{
                                                type: "upgrade",
                                                options: {
                                                    compress: true
                                                }
                                            }]);
                                            self.emit("upgrade", transport);
                                            transport = null;
                                            self.upgrading = false;
                                            self.flush()
                                        })
                                    } else {
                                        debug('probe transport "%s" failed', name);
                                        var err = new Error("probe error");
                                        err.transport = transport.name;
                                        self.emit("upgradeError", err)
                                    }
                                })
                        }
                        function freezeTransport() {
                            if (failed) return;
                            failed = true;
                            cleanup();
                            transport.close();
                            transport = null
                        }
                        function onerror(err) {
                            var error = new Error("probe error: " + err);
                            error.transport = transport.name;
                            freezeTransport();
                            debug('probe transport "%s" failed because of error: %s', name, err);
                            self.emit("upgradeError", error)
                        }
                        function onTransportClose() {
                            onerror("transport closed")
                        }
                        function onclose() {
                            onerror("socket closed")
                        }
                        function onupgrade(to) {
                            if (transport && to.name != transport.name) {
                                debug('"%s" works - aborting "%s"', to.name, transport.name);
                                freezeTransport()
                            }
                        }
                        function cleanup() {
                            transport.removeListener("open", onTransportOpen);
                            transport.removeListener("error", onerror);
                            transport.removeListener("close", onTransportClose);
                            self.removeListener("close", onclose);
                            self.removeListener("upgrading", onupgrade)
                        }
                        transport.once("open", onTransportOpen);
                        transport.once("error", onerror);
                        transport.once("close", onTransportClose);
                        this.once("close", onclose);
                        this.once("upgrading", onupgrade);
                        transport.open()
                    };
                    Socket.prototype.onOpen = function() {
                        debug("socket open");
                        this.readyState = "open";
                        Socket.priorWebsocketSuccess = "websocket" == this.transport.name;
                        this.emit("open");
                        this.flush();
                        if ("open" == this.readyState && this.upgrade && this.transport.pause) {
                            debug("starting upgrade probes");
                            for (var i = 0,
                                     l = this.upgrades.length; i < l; i++) {
                                this.probe(this.upgrades[i])
                            }
                        }
                    };
                    Socket.prototype.onPacket = function(packet) {
                        if ("opening" == this.readyState || "open" == this.readyState) {
                            debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
                            this.emit("packet", packet);
                            this.emit("heartbeat");
                            switch (packet.type) {
                                case "open":
                                    this.onHandshake(parsejson(packet.data));
                                    break;
                                case "pong":
                                    this.setPing();
                                    break;
                                case "error":
                                    var err = new Error("server error");
                                    err.code = packet.data;
                                    this.emit("error", err);
                                    break;
                                case "message":
                                    this.emit("data", packet.data);
                                    this.emit("message", packet.data);
                                    break
                            }
                        } else {
                            debug('packet received with socket readyState "%s"', this.readyState)
                        }
                    };
                    Socket.prototype.onHandshake = function(data) {
                        this.emit("handshake", data);
                        this.id = data.sid;
                        this.transport.query.sid = data.sid;
                        this.upgrades = this.filterUpgrades(data.upgrades);
                        this.pingInterval = data.pingInterval;
                        this.pingTimeout = data.pingTimeout;
                        this.onOpen();
                        if ("closed" == this.readyState) return;
                        this.setPing();
                        this.removeListener("heartbeat", this.onHeartbeat);
                        this.on("heartbeat", this.onHeartbeat)
                    };
                    Socket.prototype.onHeartbeat = function(timeout) {
                        clearTimeout(this.pingTimeoutTimer);
                        var self = this;
                        self.pingTimeoutTimer = setTimeout(function() {
                                if ("closed" == self.readyState) return;
                                self.onClose("ping timeout")
                            },
                            timeout || self.pingInterval + self.pingTimeout)
                    };
                    Socket.prototype.setPing = function() {
                        var self = this;
                        clearTimeout(self.pingIntervalTimer);
                        self.pingIntervalTimer = setTimeout(function() {
                                debug("writing ping packet - expecting pong within %sms", self.pingTimeout);
                                self.ping();
                                self.onHeartbeat(self.pingTimeout)
                            },
                            self.pingInterval)
                    };
                    Socket.prototype.ping = function() {
                        this.sendPacket("ping")
                    };
                    Socket.prototype.onDrain = function() {
                        for (var i = 0; i < this.prevBufferLen; i++) {
                            if (this.callbackBuffer[i]) {
                                this.callbackBuffer[i]()
                            }
                        }
                        this.writeBuffer.splice(0, this.prevBufferLen);
                        this.callbackBuffer.splice(0, this.prevBufferLen);
                        this.prevBufferLen = 0;
                        if (this.writeBuffer.length == 0) {
                            this.emit("drain")
                        } else {
                            this.flush()
                        }
                    };
                    Socket.prototype.flush = function() {
                        if ("closed" != this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
                            debug("flushing %d packets in socket", this.writeBuffer.length);
                            this.transport.send(this.writeBuffer);
                            this.prevBufferLen = this.writeBuffer.length;
                            this.emit("flush")
                        }
                    };
                    Socket.prototype.write = Socket.prototype.send = function(msg, options, fn) {
                        this.sendPacket("message", msg, options, fn);
                        return this
                    };
                    Socket.prototype.sendPacket = function(type, data, options, fn) {
                        if ("function" == typeof options) {
                            fn = options;
                            options = null
                        }
                        if ("closing" == this.readyState || "closed" == this.readyState) {
                            return
                        }
                        options = options || {};
                        options.compress = false !== options.compress;
                        var packet = {
                            type: type,
                            data: data,
                            options: options
                        };
                        this.emit("packetCreate", packet);
                        this.writeBuffer.push(packet);
                        this.callbackBuffer.push(fn);
                        this.flush()
                    };
                    Socket.prototype.close = function() {
                        if ("opening" == this.readyState || "open" == this.readyState) {
                            this.readyState = "closing";
                            var self = this;
                            function close() {
                                self.onClose("forced close");
                                debug("socket closing - telling transport to close");
                                self.transport.close()
                            }
                            function cleanupAndClose() {
                                self.removeListener("upgrade", cleanupAndClose);
                                self.removeListener("upgradeError", cleanupAndClose);
                                close()
                            }
                            function waitForUpgrade() {
                                self.once("upgrade", cleanupAndClose);
                                self.once("upgradeError", cleanupAndClose)
                            }
                            if (this.writeBuffer.length) {
                                this.once("drain",
                                    function() {
                                        if (this.upgrading) {
                                            waitForUpgrade()
                                        } else {
                                            close()
                                        }
                                    })
                            } else if (this.upgrading) {
                                waitForUpgrade()
                            } else {
                                close()
                            }
                        }
                        return this
                    };
                    Socket.prototype.onError = function(err) {
                        debug("socket error %j", err);
                        Socket.priorWebsocketSuccess = false;
                        this.emit("error", err);
                        this.onClose("transport error", err)
                    };
                    Socket.prototype.onClose = function(reason, desc) {
                        if ("opening" == this.readyState || "open" == this.readyState || "closing" == this.readyState) {
                            debug('socket close with reason: "%s"', reason);
                            var self = this;
                            clearTimeout(this.pingIntervalTimer);
                            clearTimeout(this.pingTimeoutTimer);
                            setTimeout(function() {
                                    self.writeBuffer = [];
                                    self.callbackBuffer = [];
                                    self.prevBufferLen = 0
                                },
                                0);
                            this.transport.removeAllListeners("close");
                            this.transport.close();
                            this.transport.removeAllListeners();
                            this.readyState = "closed";
                            this.id = null;
                            this.emit("close", reason, desc)
                        }
                    };
                    Socket.prototype.filterUpgrades = function(upgrades) {
                        var filteredUpgrades = [];
                        for (var i = 0,
                                 j = upgrades.length; i < j; i++) {
                            if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i])
                        }
                        return filteredUpgrades
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        "./transport": 14,
                        "./transports": 15,
                        "component-emitter": 9,
                        debug: 22,
                        "engine.io-parser": 25,
                        indexof: 42,
                        parsejson: 34,
                        parseqs: 35,
                        parseuri: 36
                    }],
                14 : [function(_dereq_, module, exports) {
                    var parser = _dereq_("engine.io-parser");
                    var Emitter = _dereq_("component-emitter");
                    module.exports = Transport;
                    function Transport(opts) {
                        this.path = opts.path;
                        this.hostname = opts.hostname;
                        this.port = opts.port;
                        this.secure = opts.secure;
                        this.query = opts.query;
                        this.timestampParam = opts.timestampParam;
                        this.timestampRequests = opts.timestampRequests;
                        this.readyState = "";
                        this.agent = opts.agent || false;
                        this.socket = opts.socket;
                        this.enablesXDR = opts.enablesXDR;
                        this.pfx = opts.pfx;
                        this.key = opts.key;
                        this.passphrase = opts.passphrase;
                        this.cert = opts.cert;
                        this.ca = opts.ca;
                        this.ciphers = opts.ciphers;
                        this.rejectUnauthorized = opts.rejectUnauthorized
                    }
                    Emitter(Transport.prototype);
                    Transport.timestamps = 0;
                    Transport.prototype.onError = function(msg, desc) {
                        var err = new Error(msg);
                        err.type = "TransportError";
                        err.description = desc;
                        this.emit("error", err);
                        return this
                    };
                    Transport.prototype.open = function() {
                        if ("closed" == this.readyState || "" == this.readyState) {
                            this.readyState = "opening";
                            this.doOpen()
                        }
                        return this
                    };
                    Transport.prototype.close = function() {
                        if ("opening" == this.readyState || "open" == this.readyState) {
                            this.doClose();
                            this.onClose()
                        }
                        return this
                    };
                    Transport.prototype.send = function(packets) {
                        if ("open" == this.readyState) {
                            this.write(packets)
                        } else {
                            throw new Error("Transport not open")
                        }
                    };
                    Transport.prototype.onOpen = function() {
                        this.readyState = "open";
                        this.writable = true;
                        this.emit("open")
                    };
                    Transport.prototype.onData = function(data) {
                        var packet = parser.decodePacket(data, this.socket.binaryType);
                        this.onPacket(packet)
                    };
                    Transport.prototype.onPacket = function(packet) {
                        this.emit("packet", packet)
                    };
                    Transport.prototype.onClose = function() {
                        this.readyState = "closed";
                        this.emit("close")
                    }
                },
                    {
                        "component-emitter": 9,
                        "engine.io-parser": 25
                    }],
                15 : [function(_dereq_, module, exports) { (function(global) {
                    var XMLHttpRequest = _dereq_("xmlhttprequest");
                    var XHR = _dereq_("./polling-xhr");
                    var JSONP = _dereq_("./polling-jsonp");
                    var websocket = _dereq_("./websocket");
                    exports.polling = polling;
                    exports.websocket = websocket;
                    function polling(opts) {
                        var xhr;
                        var xd = false;
                        var xs = false;
                        var jsonp = false !== opts.jsonp;
                        if (global.location) {
                            var isSSL = "https:" == location.protocol;
                            var port = location.port;
                            if (!port) {
                                port = isSSL ? 443 : 80
                            }
                            xd = opts.hostname != location.hostname || port != opts.port;
                            xs = opts.secure != isSSL
                        }
                        opts.xdomain = xd;
                        opts.xscheme = xs;
                        xhr = new XMLHttpRequest(opts);
                        if ("open" in xhr && !opts.forceJSONP) {
                            return new XHR(opts)
                        } else {
                            if (!jsonp) throw new Error("JSONP disabled");
                            return new JSONP(opts)
                        }
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        "./polling-jsonp": 16,
                        "./polling-xhr": 17,
                        "./websocket": 19,
                        xmlhttprequest: 20
                    }],
                16 : [function(_dereq_, module, exports) { (function(global) {
                    var Polling = _dereq_("./polling");
                    var inherit = _dereq_("component-inherit");
                    module.exports = JSONPPolling;
                    var rNewline = /\n/g;
                    var rEscapedNewline = /\\n/g;
                    var callbacks;
                    var index = 0;
                    function empty() {}
                    function JSONPPolling(opts) {
                        Polling.call(this, opts);
                        this.query = this.query || {};
                        if (!callbacks) {
                            if (!global.___eio) global.___eio = [];
                            callbacks = global.___eio
                        }
                        this.index = callbacks.length;
                        var self = this;
                        callbacks.push(function(msg) {
                            self.onData(msg)
                        });
                        this.query.j = this.index;
                        if (global.document && global.addEventListener) {
                            global.addEventListener("beforeunload",
                                function() {
                                    if (self.script) self.script.onerror = empty
                                },
                                false)
                        }
                    }
                    inherit(JSONPPolling, Polling);
                    JSONPPolling.prototype.supportsBinary = false;
                    JSONPPolling.prototype.doClose = function() {
                        if (this.script) {
                            this.script.parentNode.removeChild(this.script);
                            this.script = null
                        }
                        if (this.form) {
                            this.form.parentNode.removeChild(this.form);
                            this.form = null;
                            this.iframe = null
                        }
                        Polling.prototype.doClose.call(this)
                    };
                    JSONPPolling.prototype.doPoll = function() {
                        var self = this;
                        var script = document.createElement("script");
                        if (this.script) {
                            this.script.parentNode.removeChild(this.script);
                            this.script = null
                        }
                        script.async = true;
                        script.src = this.uri();
                        script.onerror = function(e) {
                            self.onError("jsonp poll error", e)
                        };
                        var insertAt = document.getElementsByTagName("script")[0];
                        insertAt.parentNode.insertBefore(script, insertAt);
                        this.script = script;
                        var isUAgecko = "undefined" != typeof navigator && /gecko/i.test(navigator.userAgent);
                        if (isUAgecko) {
                            setTimeout(function() {
                                    var iframe = document.createElement("iframe");
                                    document.body.appendChild(iframe);
                                    document.body.removeChild(iframe)
                                },
                                100)
                        }
                    };
                    JSONPPolling.prototype.doWrite = function(data, fn) {
                        var self = this;
                        if (!this.form) {
                            var form = document.createElement("form");
                            var area = document.createElement("textarea");
                            var id = this.iframeId = "eio_iframe_" + this.index;
                            var iframe;
                            form.className = "socketio";
                            form.style.position = "absolute";
                            form.style.top = "-1000px";
                            form.style.left = "-1000px";
                            form.target = id;
                            form.method = "POST";
                            form.setAttribute("accept-charset", "utf-8");
                            area.name = "d";
                            form.appendChild(area);
                            document.body.appendChild(form);
                            this.form = form;
                            this.area = area
                        }
                        this.form.action = this.uri();
                        function complete() {
                            initIframe();
                            fn()
                        }
                        function initIframe() {
                            if (self.iframe) {
                                try {
                                    self.form.removeChild(self.iframe)
                                } catch(e) {
                                    self.onError("jsonp polling iframe removal error", e)
                                }
                            }
                            try {
                                var html = '<iframe src="javascript:0" name="' + self.iframeId + '">';
                                iframe = document.createElement(html)
                            } catch(e) {
                                iframe = document.createElement("iframe");
                                iframe.name = self.iframeId;
                                iframe.src = "javascript:0"
                            }
                            iframe.id = self.iframeId;
                            self.form.appendChild(iframe);
                            self.iframe = iframe
                        }
                        initIframe();
                        data = data.replace(rEscapedNewline, "\\\n");
                        this.area.value = data.replace(rNewline, "\\n");
                        try {
                            this.form.submit()
                        } catch(e) {}
                        if (this.iframe.attachEvent) {
                            this.iframe.onreadystatechange = function() {
                                if (self.iframe.readyState == "complete") {
                                    complete()
                                }
                            }
                        } else {
                            this.iframe.onload = complete
                        }
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        "./polling": 18,
                        "component-inherit": 21
                    }],
                17 : [function(_dereq_, module, exports) { (function(global) {
                    var XMLHttpRequest = _dereq_("xmlhttprequest");
                    var Polling = _dereq_("./polling");
                    var Emitter = _dereq_("component-emitter");
                    var inherit = _dereq_("component-inherit");
                    var debug = _dereq_("debug")("engine.io-client:polling-xhr");
                    module.exports = XHR;
                    module.exports.Request = Request;
                    function empty() {}
                    function XHR(opts) {
                        Polling.call(this, opts);
                        if (global.location) {
                            var isSSL = "https:" == location.protocol;
                            var port = location.port;
                            if (!port) {
                                port = isSSL ? 443 : 80
                            }
                            this.xd = opts.hostname != global.location.hostname || port != opts.port;
                            this.xs = opts.secure != isSSL
                        }
                    }
                    inherit(XHR, Polling);
                    XHR.prototype.supportsBinary = true;
                    XHR.prototype.request = function(opts) {
                        opts = opts || {};
                        opts.uri = this.uri();
                        opts.xd = this.xd;
                        opts.xs = this.xs;
                        opts.agent = this.agent || false;
                        opts.supportsBinary = this.supportsBinary;
                        opts.enablesXDR = this.enablesXDR;
                        opts.pfx = this.pfx;
                        opts.key = this.key;
                        opts.passphrase = this.passphrase;
                        opts.cert = this.cert;
                        opts.ca = this.ca;
                        opts.ciphers = this.ciphers;
                        opts.rejectUnauthorized = this.rejectUnauthorized;
                        return new Request(opts)
                    };
                    XHR.prototype.doWrite = function(data, fn) {
                        var isBinary = typeof data !== "string" && data !== undefined;
                        var req = this.request({
                            method: "POST",
                            data: data,
                            isBinary: isBinary
                        });
                        var self = this;
                        req.on("success", fn);
                        req.on("error",
                            function(err) {
                                self.onError("xhr post error", err)
                            });
                        this.sendXhr = req
                    };
                    XHR.prototype.doPoll = function() {
                        debug("xhr poll");
                        var req = this.request();
                        var self = this;
                        req.on("data",
                            function(data) {
                                self.onData(data)
                            });
                        req.on("error",
                            function(err) {
                                self.onError("xhr poll error", err)
                            });
                        this.pollXhr = req
                    };
                    function Request(opts) {
                        this.method = opts.method || "GET";
                        this.uri = opts.uri;
                        this.xd = !!opts.xd;
                        this.xs = !!opts.xs;
                        this.async = false !== opts.async;
                        this.data = undefined != opts.data ? opts.data: null;
                        this.agent = opts.agent;
                        this.isBinary = opts.isBinary;
                        this.supportsBinary = opts.supportsBinary;
                        this.enablesXDR = opts.enablesXDR;
                        this.pfx = opts.pfx;
                        this.key = opts.key;
                        this.passphrase = opts.passphrase;
                        this.cert = opts.cert;
                        this.ca = opts.ca;
                        this.ciphers = opts.ciphers;
                        this.rejectUnauthorized = opts.rejectUnauthorized;
                        this.create()
                    }
                    Emitter(Request.prototype);
                    Request.prototype.create = function() {
                        var opts = {
                            agent: this.agent,
                            xdomain: this.xd,
                            xscheme: this.xs,
                            enablesXDR: this.enablesXDR
                        };
                        opts.pfx = this.pfx;
                        opts.key = this.key;
                        opts.passphrase = this.passphrase;
                        opts.cert = this.cert;
                        opts.ca = this.ca;
                        opts.ciphers = this.ciphers;
                        opts.rejectUnauthorized = this.rejectUnauthorized;
                        var xhr = this.xhr = new XMLHttpRequest(opts);
                        var self = this;
                        try {
                            debug("xhr open %s: %s", this.method, this.uri);
                            xhr.open(this.method, this.uri, this.async);
                            if (this.supportsBinary) {
                                xhr.responseType = "arraybuffer"
                            }
                            if ("POST" == this.method) {
                                try {
                                    if (this.isBinary) {
                                        xhr.setRequestHeader("Content-type", "application/octet-stream")
                                    } else {
                                        xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8")
                                    }
                                } catch(e) {}
                            }
                            if ("withCredentials" in xhr) {
                                xhr.withCredentials = true
                            }
                            if (this.hasXDR()) {
                                xhr.onload = function() {
                                    self.onLoad()
                                };
                                xhr.onerror = function() {
                                    self.onError(xhr.responseText)
                                }
                            } else {
                                xhr.onreadystatechange = function() {
                                    if (4 != xhr.readyState) return;
                                    if (200 == xhr.status || 1223 == xhr.status) {
                                        self.onLoad()
                                    } else {
                                        setTimeout(function() {
                                                self.onError(xhr.status)
                                            },
                                            0)
                                    }
                                }
                            }
                            debug("xhr data %s", this.data);
                            xhr.send(this.data)
                        } catch(e) {
                            setTimeout(function() {
                                    self.onError(e)
                                },
                                0);
                            return
                        }
                        if (global.document) {
                            this.index = Request.requestsCount++;
                            Request.requests[this.index] = this
                        }
                    };
                    Request.prototype.onSuccess = function() {
                        this.emit("success");
                        this.cleanup()
                    };
                    Request.prototype.onData = function(data) {
                        this.emit("data", data);
                        this.onSuccess()
                    };
                    Request.prototype.onError = function(err) {
                        this.emit("error", err);
                        this.cleanup(true)
                    };
                    Request.prototype.cleanup = function(fromError) {
                        if ("undefined" == typeof this.xhr || null === this.xhr) {
                            return
                        }
                        if (this.hasXDR()) {
                            this.xhr.onload = this.xhr.onerror = empty
                        } else {
                            this.xhr.onreadystatechange = empty
                        }
                        if (fromError) {
                            try {
                                this.xhr.abort()
                            } catch(e) {}
                        }
                        if (global.document) {
                            delete Request.requests[this.index]
                        }
                        this.xhr = null
                    };
                    Request.prototype.onLoad = function() {
                        var data;
                        try {
                            var contentType;
                            try {
                                contentType = this.xhr.getResponseHeader("Content-Type").split(";")[0]
                            } catch(e) {}
                            if (contentType === "application/octet-stream") {
                                data = this.xhr.response
                            } else {
                                if (!this.supportsBinary) {
                                    data = this.xhr.responseText
                                } else {
                                    data = "ok"
                                }
                            }
                        } catch(e) {
                            this.onError(e)
                        }
                        if (null != data) {
                            this.onData(data)
                        }
                    };
                    Request.prototype.hasXDR = function() {
                        return "undefined" !== typeof global.XDomainRequest && !this.xs && this.enablesXDR
                    };
                    Request.prototype.abort = function() {
                        this.cleanup()
                    };
                    if (global.document) {
                        Request.requestsCount = 0;
                        Request.requests = {};
                        if (global.attachEvent) {
                            global.attachEvent("onunload", unloadHandler)
                        } else if (global.addEventListener) {
                            global.addEventListener("beforeunload", unloadHandler, false)
                        }
                    }
                    function unloadHandler() {
                        for (var i in Request.requests) {
                            if (Request.requests.hasOwnProperty(i)) {
                                Request.requests[i].abort()
                            }
                        }
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        "./polling": 18,
                        "component-emitter": 9,
                        "component-inherit": 21,
                        debug: 22,
                        xmlhttprequest: 20
                    }],
                18 : [function(_dereq_, module, exports) {
                    var Transport = _dereq_("../transport");
                    var parseqs = _dereq_("parseqs");
                    var parser = _dereq_("engine.io-parser");
                    var inherit = _dereq_("component-inherit");
                    var debug = _dereq_("debug")("engine.io-client:polling");
                    module.exports = Polling;
                    var hasXHR2 = function() {
                        var XMLHttpRequest = _dereq_("xmlhttprequest");
                        var xhr = new XMLHttpRequest({
                            xdomain: false
                        });
                        return null != xhr.responseType
                    } ();
                    function Polling(opts) {
                        var forceBase64 = opts && opts.forceBase64;
                        if (!hasXHR2 || forceBase64) {
                            this.supportsBinary = false
                        }
                        Transport.call(this, opts)
                    }
                    inherit(Polling, Transport);
                    Polling.prototype.name = "polling";
                    Polling.prototype.doOpen = function() {
                        this.poll()
                    };
                    Polling.prototype.pause = function(onPause) {
                        var pending = 0;
                        var self = this;
                        this.readyState = "pausing";
                        function pause() {
                            debug("paused");
                            self.readyState = "paused";
                            onPause()
                        }
                        if (this.polling || !this.writable) {
                            var total = 0;
                            if (this.polling) {
                                debug("we are currently polling - waiting to pause");
                                total++;
                                this.once("pollComplete",
                                    function() {
                                        debug("pre-pause polling complete"); --total || pause()
                                    })
                            }
                            if (!this.writable) {
                                debug("we are currently writing - waiting to pause");
                                total++;
                                this.once("drain",
                                    function() {
                                        debug("pre-pause writing complete"); --total || pause()
                                    })
                            }
                        } else {
                            pause()
                        }
                    };
                    Polling.prototype.poll = function() {
                        debug("polling");
                        this.polling = true;
                        this.doPoll();
                        this.emit("poll")
                    };
                    Polling.prototype.onData = function(data) {
                        var self = this;
                        debug("polling got data %s", data);
                        var callback = function(packet, index, total) {
                            if ("opening" == self.readyState) {
                                self.onOpen()
                            }
                            if ("close" == packet.type) {
                                self.onClose();
                                return false
                            }
                            self.onPacket(packet)
                        };
                        parser.decodePayload(data, this.socket.binaryType, callback);
                        if ("closed" != this.readyState) {
                            this.polling = false;
                            this.emit("pollComplete");
                            if ("open" == this.readyState) {
                                this.poll()
                            } else {
                                debug('ignoring poll - transport state "%s"', this.readyState)
                            }
                        }
                    };
                    Polling.prototype.doClose = function() {
                        var self = this;
                        function close() {
                            debug("writing close packet");
                            self.write([{
                                type: "close"
                            }])
                        }
                        if ("open" == this.readyState) {
                            debug("transport open - closing");
                            close()
                        } else {
                            debug("transport not open - deferring close");
                            this.once("open", close)
                        }
                    };
                    Polling.prototype.write = function(packets) {
                        var self = this;
                        this.writable = false;
                        var callbackfn = function() {
                            self.writable = true;
                            self.emit("drain")
                        };
                        var self = this;
                        parser.encodePayload(packets, this.supportsBinary,
                            function(data) {
                                self.doWrite(data, callbackfn)
                            })
                    };
                    Polling.prototype.uri = function() {
                        var query = this.query || {};
                        var schema = this.secure ? "https": "http";
                        var port = "";
                        if (false !== this.timestampRequests) {
                            query[this.timestampParam] = +new Date + "-" + Transport.timestamps++
                        }
                        if (!this.supportsBinary && !query.sid) {
                            query.b64 = 1
                        }
                        query = parseqs.encode(query);
                        if (this.port && ("https" == schema && this.port != 443 || "http" == schema && this.port != 80)) {
                            port = ":" + this.port
                        }
                        if (query.length) {
                            query = "?" + query
                        }
                        return schema + "://" + this.hostname + port + this.path + query
                    }
                },
                    {
                        "../transport": 14,
                        "component-inherit": 21,
                        debug: 22,
                        "engine.io-parser": 25,
                        parseqs: 35,
                        xmlhttprequest: 20
                    }],
                19 : [function(_dereq_, module, exports) {
                    var Transport = _dereq_("../transport");
                    var parser = _dereq_("engine.io-parser");
                    var parseqs = _dereq_("parseqs");
                    var inherit = _dereq_("component-inherit");
                    var debug = _dereq_("debug")("engine.io-client:websocket");
                    var WebSocket = _dereq_("ws");
                    module.exports = WS;
                    function WS(opts) {
                        var forceBase64 = opts && opts.forceBase64;
                        if (forceBase64) {
                            this.supportsBinary = false
                        }
                        this.perMessageDeflate = opts.perMessageDeflate;
                        Transport.call(this, opts)
                    }
                    inherit(WS, Transport);
                    WS.prototype.name = "websocket";
                    WS.prototype.supportsBinary = true;
                    WS.prototype.doOpen = function() {
                        if (!this.check()) {
                            return
                        }
                        var self = this;
                        var uri = this.uri();
                        var protocols = void 0;
                        var opts = {
                            agent: this.agent,
                            perMessageDeflate: this.perMessageDeflate
                        };
                        opts.pfx = this.pfx;
                        opts.key = this.key;
                        opts.passphrase = this.passphrase;
                        opts.cert = this.cert;
                        opts.ca = this.ca;
                        opts.ciphers = this.ciphers;
                        opts.rejectUnauthorized = this.rejectUnauthorized;
                        this.ws = new WebSocket(uri, protocols, opts);
                        if (this.ws.binaryType === undefined) {
                            this.supportsBinary = false
                        }
                        this.ws.binaryType = "arraybuffer";
                        this.addEventListeners()
                    };
                    WS.prototype.addEventListeners = function() {
                        var self = this;
                        this.ws.onopen = function() {
                            self.onOpen()
                        };
                        this.ws.onclose = function() {
                            self.onClose()
                        };
                        this.ws.onmessage = function(ev) {
                            self.onData(ev.data)
                        };
                        this.ws.onerror = function(e) {
                            self.onError("websocket error", e)
                        }
                    };
                    if ("undefined" != typeof navigator && /iPad|iPhone|iPod/i.test(navigator.userAgent)) {
                        WS.prototype.onData = function(data) {
                            var self = this;
                            setTimeout(function() {
                                    Transport.prototype.onData.call(self, data)
                                },
                                0)
                        }
                    }
                    WS.prototype.write = function(packets) {
                        var self = this;
                        this.writable = false;
                        for (var i = 0,
                                 l = packets.length; i < l; i++) {
                            var packet = packets[i];
                            parser.encodePacket(packet, this.supportsBinary,
                                function(data) {
                                    try {
                                        self.ws.send(data, packet.options)
                                    } catch(e) {
                                        debug("websocket closed before onclose event")
                                    }
                                })
                        }
                        function ondrain() {
                            self.writable = true;
                            self.emit("drain")
                        }
                        setTimeout(ondrain, 0)
                    };
                    WS.prototype.onClose = function() {
                        Transport.prototype.onClose.call(this)
                    };
                    WS.prototype.doClose = function() {
                        if (typeof this.ws !== "undefined") {
                            this.ws.close()
                        }
                    };
                    WS.prototype.uri = function() {
                        var query = this.query || {};
                        var schema = this.secure ? "wss": "ws";
                        var port = "";
                        if (this.port && ("wss" == schema && this.port != 443 || "ws" == schema && this.port != 80)) {
                            port = ":" + this.port
                        }
                        if (this.timestampRequests) {
                            query[this.timestampParam] = +new Date
                        }
                        if (!this.supportsBinary) {
                            query.b64 = 1
                        }
                        query = parseqs.encode(query);
                        if (query.length) {
                            query = "?" + query
                        }
                        return schema + "://" + this.hostname + port + this.path + query
                    };
                    WS.prototype.check = function() {
                        return !! WebSocket && !("__initialize" in WebSocket && this.name === WS.prototype.name)
                    }
                },
                    {
                        "../transport": 14,
                        "component-inherit": 21,
                        debug: 22,
                        "engine.io-parser": 25,
                        parseqs: 35,
                        ws: 37
                    }],
                20 : [function(_dereq_, module, exports) {
                    var hasCORS = _dereq_("has-cors");
                    module.exports = function(opts) {
                        var xdomain = opts.xdomain;
                        var xscheme = opts.xscheme;
                        var enablesXDR = opts.enablesXDR;
                        try {
                            if ("undefined" != typeof XMLHttpRequest && (!xdomain || hasCORS)) {
                                return new XMLHttpRequest
                            }
                        } catch(e) {}
                        try {
                            if ("undefined" != typeof XDomainRequest && !xscheme && enablesXDR) {
                                return new XDomainRequest
                            }
                        } catch(e) {}
                        if (!xdomain) {
                            try {
                                return new ActiveXObject("Microsoft.XMLHTTP")
                            } catch(e) {}
                        }
                    }
                },
                    {
                        "has-cors": 40
                    }],
                21 : [function(_dereq_, module, exports) {
                    module.exports = function(a, b) {
                        var fn = function() {};
                        fn.prototype = b.prototype;
                        a.prototype = new fn;
                        a.prototype.constructor = a
                    }
                },
                    {}],
                22 : [function(_dereq_, module, exports) {
                    exports = module.exports = _dereq_("./debug");
                    exports.log = log;
                    exports.formatArgs = formatArgs;
                    exports.save = save;
                    exports.load = load;
                    exports.useColors = useColors;
                    exports.colors = ["lightseagreen", "forestgreen", "goldenrod", "dodgerblue", "darkorchid", "crimson"];
                    function useColors() {
                        return "WebkitAppearance" in document.documentElement.style || window.console && (console.firebug || console.exception && console.table) || navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31
                    }
                    exports.formatters.j = function(v) {
                        return JSON.stringify(v)
                    };
                    function formatArgs() {
                        var args = arguments;
                        var useColors = this.useColors;
                        args[0] = (useColors ? "%c": "") + this.namespace + (useColors ? " %c": " ") + args[0] + (useColors ? "%c ": " ") + "+" + exports.humanize(this.diff);
                        if (!useColors) return args;
                        var c = "color: " + this.color;
                        args = [args[0], c, "color: inherit"].concat(Array.prototype.slice.call(args, 1));
                        var index = 0;
                        var lastC = 0;
                        args[0].replace(/%[a-z%]/g,
                            function(match) {
                                if ("%" === match) return;
                                index++;
                                if ("%c" === match) {
                                    lastC = index
                                }
                            });
                        args.splice(lastC, 0, c);
                        return args
                    }
                    function log() {
                        return "object" == typeof console && "function" == typeof console.log && Function.prototype.apply.call(console.log, console, arguments)
                    }
                    function save(namespaces) {
                        try {
                            if (null == namespaces) {
                                localStorage.removeItem("debug")
                            } else {
                                localStorage.debug = namespaces
                            }
                        } catch(e) {}
                    }
                    function load() {
                        var r;
                        try {
                            r = localStorage.debug
                        } catch(e) {}
                        return r
                    }
                    exports.enable(load())
                },
                    {
                        "./debug": 23
                    }],
                23 : [function(_dereq_, module, exports) {
                    exports = module.exports = debug;
                    exports.coerce = coerce;
                    exports.disable = disable;
                    exports.enable = enable;
                    exports.enabled = enabled;
                    exports.humanize = _dereq_("ms");
                    exports.names = [];
                    exports.skips = [];
                    exports.formatters = {};
                    var prevColor = 0;
                    var prevTime;
                    function selectColor() {
                        return exports.colors[prevColor++%exports.colors.length]
                    }
                    function debug(namespace) {
                        function disabled() {}
                        disabled.enabled = false;
                        function enabled() {
                            var self = enabled;
                            var curr = +new Date;
                            var ms = curr - (prevTime || curr);
                            self.diff = ms;
                            self.prev = prevTime;
                            self.curr = curr;
                            prevTime = curr;
                            if (null == self.useColors) self.useColors = exports.useColors();
                            if (null == self.color && self.useColors) self.color = selectColor();
                            var args = Array.prototype.slice.call(arguments);
                            args[0] = exports.coerce(args[0]);
                            if ("string" !== typeof args[0]) {
                                args = ["%o"].concat(args)
                            }
                            var index = 0;
                            args[0] = args[0].replace(/%([a-z%])/g,
                                function(match, format) {
                                    if (match === "%") return match;
                                    index++;
                                    var formatter = exports.formatters[format];
                                    if ("function" === typeof formatter) {
                                        var val = args[index];
                                        match = formatter.call(self, val);
                                        args.splice(index, 1);
                                        index--
                                    }
                                    return match
                                });
                            if ("function" === typeof exports.formatArgs) {
                                args = exports.formatArgs.apply(self, args)
                            }
                            var logFn = enabled.log || exports.log || console.log.bind(console);
                            logFn.apply(self, args)
                        }
                        enabled.enabled = true;
                        var fn = exports.enabled(namespace) ? enabled: disabled;
                        fn.namespace = namespace;
                        return fn
                    }
                    function enable(namespaces) {
                        exports.save(namespaces);
                        var split = (namespaces || "").split(/[\s,]+/);
                        var len = split.length;
                        for (var i = 0; i < len; i++) {
                            if (!split[i]) continue;
                            namespaces = split[i].replace(/\*/g, ".*?");
                            if (namespaces[0] === "-") {
                                exports.skips.push(new RegExp("^" + namespaces.substr(1) + "$"))
                            } else {
                                exports.names.push(new RegExp("^" + namespaces + "$"))
                            }
                        }
                    }
                    function disable() {
                        exports.enable("")
                    }
                    function enabled(name) {
                        var i, len;
                        for (i = 0, len = exports.skips.length; i < len; i++) {
                            if (exports.skips[i].test(name)) {
                                return false
                            }
                        }
                        for (i = 0, len = exports.names.length; i < len; i++) {
                            if (exports.names[i].test(name)) {
                                return true
                            }
                        }
                        return false
                    }
                    function coerce(val) {
                        if (val instanceof Error) return val.stack || val.message;
                        return val
                    }
                },
                    {
                        ms: 24
                    }],
                24 : [function(_dereq_, module, exports) {
                    var s = 1e3;
                    var m = s * 60;
                    var h = m * 60;
                    var d = h * 24;
                    var y = d * 365.25;
                    module.exports = function(val, options) {
                        options = options || {};
                        if ("string" == typeof val) return parse(val);
                        return options.long ? long(val) : short(val)
                    };
                    function parse(str) {
                        var match = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);
                        if (!match) return;
                        var n = parseFloat(match[1]);
                        var type = (match[2] || "ms").toLowerCase();
                        switch (type) {
                            case "years":
                            case "year":
                            case "y":
                                return n * y;
                            case "days":
                            case "day":
                            case "d":
                                return n * d;
                            case "hours":
                            case "hour":
                            case "h":
                                return n * h;
                            case "minutes":
                            case "minute":
                            case "m":
                                return n * m;
                            case "seconds":
                            case "second":
                            case "s":
                                return n * s;
                            case "ms":
                                return n
                        }
                    }
                    function short(ms) {
                        if (ms >= d) return Math.round(ms / d) + "d";
                        if (ms >= h) return Math.round(ms / h) + "h";
                        if (ms >= m) return Math.round(ms / m) + "m";
                        if (ms >= s) return Math.round(ms / s) + "s";
                        return ms + "ms"
                    }
                    function long(ms) {
                        return plural(ms, d, "day") || plural(ms, h, "hour") || plural(ms, m, "minute") || plural(ms, s, "second") || ms + " ms"
                    }
                    function plural(ms, n, name) {
                        if (ms < n) return;
                        if (ms < n * 1.5) return Math.floor(ms / n) + " " + name;
                        return Math.ceil(ms / n) + " " + name + "s"
                    }
                },
                    {}],
                25 : [function(_dereq_, module, exports) { (function(global) {
                    var keys = _dereq_("./keys");
                    var hasBinary = _dereq_("has-binary");
                    var sliceBuffer = _dereq_("arraybuffer.slice");
                    var base64encoder = _dereq_("base64-arraybuffer");
                    var after = _dereq_("after");
                    var utf8 = _dereq_("utf8");
                    var isAndroid = navigator.userAgent.match(/Android/i);
                    var isPhantomJS = /PhantomJS/i.test(navigator.userAgent);
                    var dontSendBlobs = isAndroid || isPhantomJS;
                    exports.protocol = 3;
                    var packets = exports.packets = {
                        open: 0,
                        close: 1,
                        ping: 2,
                        pong: 3,
                        message: 4,
                        upgrade: 5,
                        noop: 6
                    };
                    var packetslist = keys(packets);
                    var err = {
                        type: "error",
                        data: "parser error"
                    };
                    var Blob = _dereq_("blob");
                    exports.encodePacket = function(packet, supportsBinary, utf8encode, callback) {
                        if ("function" == typeof supportsBinary) {
                            callback = supportsBinary;
                            supportsBinary = false
                        }
                        if ("function" == typeof utf8encode) {
                            callback = utf8encode;
                            utf8encode = null
                        }
                        var data = packet.data === undefined ? undefined: packet.data.buffer || packet.data;
                        if (global.ArrayBuffer && data instanceof ArrayBuffer) {
                            return encodeArrayBuffer(packet, supportsBinary, callback)
                        } else if (Blob && data instanceof global.Blob) {
                            return encodeBlob(packet, supportsBinary, callback)
                        }
                        if (data && data.base64) {
                            return encodeBase64Object(packet, callback)
                        }
                        var encoded = packets[packet.type];
                        if (undefined !== packet.data) {
                            encoded += utf8encode ? utf8.encode(String(packet.data)) : String(packet.data)
                        }
                        return callback("" + encoded)
                    };
                    function encodeBase64Object(packet, callback) {
                        var message = "b" + exports.packets[packet.type] + packet.data.data;
                        return callback(message)
                    }
                    function encodeArrayBuffer(packet, supportsBinary, callback) {
                        if (!supportsBinary) {
                            return exports.encodeBase64Packet(packet, callback)
                        }
                        var data = packet.data;
                        var contentArray = new Uint8Array(data);
                        var resultBuffer = new Uint8Array(1 + data.byteLength);
                        resultBuffer[0] = packets[packet.type];
                        for (var i = 0; i < contentArray.length; i++) {
                            resultBuffer[i + 1] = contentArray[i]
                        }
                        return callback(resultBuffer.buffer)
                    }
                    function encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {
                        if (!supportsBinary) {
                            return exports.encodeBase64Packet(packet, callback)
                        }
                        var fr = new FileReader;
                        fr.onload = function() {
                            packet.data = fr.result;
                            exports.encodePacket(packet, supportsBinary, true, callback)
                        };
                        return fr.readAsArrayBuffer(packet.data)
                    }
                    function encodeBlob(packet, supportsBinary, callback) {
                        if (!supportsBinary) {
                            return exports.encodeBase64Packet(packet, callback)
                        }
                        if (dontSendBlobs) {
                            return encodeBlobAsArrayBuffer(packet, supportsBinary, callback)
                        }
                        var length = new Uint8Array(1);
                        length[0] = packets[packet.type];
                        var blob = new Blob([length.buffer, packet.data]);
                        return callback(blob)
                    }
                    exports.encodeBase64Packet = function(packet, callback) {
                        var message = "b" + exports.packets[packet.type];
                        if (Blob && packet.data instanceof Blob) {
                            var fr = new FileReader;
                            fr.onload = function() {
                                var b64 = fr.result.split(",")[1];
                                callback(message + b64)
                            };
                            return fr.readAsDataURL(packet.data)
                        }
                        var b64data;
                        try {
                            b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data))
                        } catch(e) {
                            var typed = new Uint8Array(packet.data);
                            var basic = new Array(typed.length);
                            for (var i = 0; i < typed.length; i++) {
                                basic[i] = typed[i]
                            }
                            b64data = String.fromCharCode.apply(null, basic)
                        }
                        message += global.btoa(b64data);
                        return callback(message)
                    };
                    exports.decodePacket = function(data, binaryType, utf8decode) {
                        if (typeof data == "string" || data === undefined) {
                            if (data.charAt(0) == "b") {
                                return exports.decodeBase64Packet(data.substr(1), binaryType)
                            }
                            if (utf8decode) {
                                try {
                                    data = utf8.decode(data)
                                } catch(e) {
                                    return err
                                }
                            }
                            var type = data.charAt(0);
                            if (Number(type) != type || !packetslist[type]) {
                                return err
                            }
                            if (data.length > 1) {
                                return {
                                    type: packetslist[type],
                                    data: data.substring(1)
                                }
                            } else {
                                return {
                                    type: packetslist[type]
                                }
                            }
                        }
                        var asArray = new Uint8Array(data);
                        var type = asArray[0];
                        var rest = sliceBuffer(data, 1);
                        if (Blob && binaryType === "blob") {
                            rest = new Blob([rest])
                        }
                        return {
                            type: packetslist[type],
                            data: rest
                        }
                    };
                    exports.decodeBase64Packet = function(msg, binaryType) {
                        var type = packetslist[msg.charAt(0)];
                        if (!global.ArrayBuffer) {
                            return {
                                type: type,
                                data: {
                                    base64: true,
                                    data: msg.substr(1)
                                }
                            }
                        }
                        var data = base64encoder.decode(msg.substr(1));
                        if (binaryType === "blob" && Blob) {
                            data = new Blob([data])
                        }
                        return {
                            type: type,
                            data: data
                        }
                    };
                    exports.encodePayload = function(packets, supportsBinary, callback) {
                        if (typeof supportsBinary == "function") {
                            callback = supportsBinary;
                            supportsBinary = null
                        }
                        var isBinary = hasBinary(packets);
                        if (supportsBinary && isBinary) {
                            if (Blob && !dontSendBlobs) {
                                return exports.encodePayloadAsBlob(packets, callback)
                            }
                            return exports.encodePayloadAsArrayBuffer(packets, callback)
                        }
                        if (!packets.length) {
                            return callback("0:")
                        }
                        function setLengthHeader(message) {
                            return message.length + ":" + message
                        }
                        function encodeOne(packet, doneCallback) {
                            exports.encodePacket(packet, !isBinary ? false: supportsBinary, true,
                                function(message) {
                                    doneCallback(null, setLengthHeader(message))
                                })
                        }
                        map(packets, encodeOne,
                            function(err, results) {
                                return callback(results.join(""))
                            })
                    };
                    function map(ary, each, done) {
                        var result = new Array(ary.length);
                        var next = after(ary.length, done);
                        var eachWithIndex = function(i, el, cb) {
                            each(el,
                                function(error, msg) {
                                    result[i] = msg;
                                    cb(error, result)
                                })
                        };
                        for (var i = 0; i < ary.length; i++) {
                            eachWithIndex(i, ary[i], next)
                        }
                    }
                    exports.decodePayload = function(data, binaryType, callback) {
                        if (typeof data != "string") {
                            return exports.decodePayloadAsBinary(data, binaryType, callback)
                        }
                        if (typeof binaryType === "function") {
                            callback = binaryType;
                            binaryType = null
                        }
                        var packet;
                        if (data == "") {
                            return callback(err, 0, 1)
                        }
                        var length = "",
                            n, msg;
                        for (var i = 0,
                                 l = data.length; i < l; i++) {
                            var chr = data.charAt(i);
                            if (":" != chr) {
                                length += chr
                            } else {
                                if ("" == length || length != (n = Number(length))) {
                                    return callback(err, 0, 1)
                                }
                                msg = data.substr(i + 1, n);
                                if (length != msg.length) {
                                    return callback(err, 0, 1)
                                }
                                if (msg.length) {
                                    packet = exports.decodePacket(msg, binaryType, true);
                                    if (err.type == packet.type && err.data == packet.data) {
                                        return callback(err, 0, 1)
                                    }
                                    var ret = callback(packet, i + n, l);
                                    if (false === ret) return
                                }
                                i += n;
                                length = ""
                            }
                        }
                        if (length != "") {
                            return callback(err, 0, 1)
                        }
                    };
                    exports.encodePayloadAsArrayBuffer = function(packets, callback) {
                        if (!packets.length) {
                            return callback(new ArrayBuffer(0))
                        }
                        function encodeOne(packet, doneCallback) {
                            exports.encodePacket(packet, true, true,
                                function(data) {
                                    return doneCallback(null, data)
                                })
                        }
                        map(packets, encodeOne,
                            function(err, encodedPackets) {
                                var totalLength = encodedPackets.reduce(function(acc, p) {
                                        var len;
                                        if (typeof p === "string") {
                                            len = p.length
                                        } else {
                                            len = p.byteLength
                                        }
                                        return acc + len.toString().length + len + 2
                                    },
                                    0);
                                var resultArray = new Uint8Array(totalLength);
                                var bufferIndex = 0;
                                encodedPackets.forEach(function(p) {
                                    var isString = typeof p === "string";
                                    var ab = p;
                                    if (isString) {
                                        var view = new Uint8Array(p.length);
                                        for (var i = 0; i < p.length; i++) {
                                            view[i] = p.charCodeAt(i)
                                        }
                                        ab = view.buffer
                                    }
                                    if (isString) {
                                        resultArray[bufferIndex++] = 0
                                    } else {
                                        resultArray[bufferIndex++] = 1
                                    }
                                    var lenStr = ab.byteLength.toString();
                                    for (var i = 0; i < lenStr.length; i++) {
                                        resultArray[bufferIndex++] = parseInt(lenStr[i])
                                    }
                                    resultArray[bufferIndex++] = 255;
                                    var view = new Uint8Array(ab);
                                    for (var i = 0; i < view.length; i++) {
                                        resultArray[bufferIndex++] = view[i]
                                    }
                                });
                                return callback(resultArray.buffer)
                            })
                    };
                    exports.encodePayloadAsBlob = function(packets, callback) {
                        function encodeOne(packet, doneCallback) {
                            exports.encodePacket(packet, true, true,
                                function(encoded) {
                                    var binaryIdentifier = new Uint8Array(1);
                                    binaryIdentifier[0] = 1;
                                    if (typeof encoded === "string") {
                                        var view = new Uint8Array(encoded.length);
                                        for (var i = 0; i < encoded.length; i++) {
                                            view[i] = encoded.charCodeAt(i)
                                        }
                                        encoded = view.buffer;
                                        binaryIdentifier[0] = 0
                                    }
                                    var len = encoded instanceof ArrayBuffer ? encoded.byteLength: encoded.size;
                                    var lenStr = len.toString();
                                    var lengthAry = new Uint8Array(lenStr.length + 1);
                                    for (var i = 0; i < lenStr.length; i++) {
                                        lengthAry[i] = parseInt(lenStr[i])
                                    }
                                    lengthAry[lenStr.length] = 255;
                                    if (Blob) {
                                        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);
                                        doneCallback(null, blob)
                                    }
                                })
                        }
                        map(packets, encodeOne,
                            function(err, results) {
                                return callback(new Blob(results))
                            })
                    };
                    exports.decodePayloadAsBinary = function(data, binaryType, callback) {
                        if (typeof binaryType === "function") {
                            callback = binaryType;
                            binaryType = null
                        }
                        var bufferTail = data;
                        var buffers = [];
                        var numberTooLong = false;
                        while (bufferTail.byteLength > 0) {
                            var tailArray = new Uint8Array(bufferTail);
                            var isString = tailArray[0] === 0;
                            var msgLength = "";
                            for (var i = 1;; i++) {
                                if (tailArray[i] == 255) break;
                                if (msgLength.length > 310) {
                                    numberTooLong = true;
                                    break
                                }
                                msgLength += tailArray[i]
                            }
                            if (numberTooLong) return callback(err, 0, 1);
                            bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);
                            msgLength = parseInt(msgLength);
                            var msg = sliceBuffer(bufferTail, 0, msgLength);
                            if (isString) {
                                try {
                                    msg = String.fromCharCode.apply(null, new Uint8Array(msg))
                                } catch(e) {
                                    var typed = new Uint8Array(msg);
                                    msg = "";
                                    for (var i = 0; i < typed.length; i++) {
                                        msg += String.fromCharCode(typed[i])
                                    }
                                }
                            }
                            buffers.push(msg);
                            bufferTail = sliceBuffer(bufferTail, msgLength)
                        }
                        var total = buffers.length;
                        buffers.forEach(function(buffer, i) {
                            callback(exports.decodePacket(buffer, binaryType, true), i, total)
                        })
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        "./keys": 26,
                        after: 27,
                        "arraybuffer.slice": 28,
                        "base64-arraybuffer": 29,
                        blob: 30,
                        "has-binary": 31,
                        utf8: 33
                    }],
                26 : [function(_dereq_, module, exports) {
                    module.exports = Object.keys ||
                        function keys(obj) {
                            var arr = [];
                            var has = Object.prototype.hasOwnProperty;
                            for (var i in obj) {
                                if (has.call(obj, i)) {
                                    arr.push(i)
                                }
                            }
                            return arr
                        }
                },
                    {}],
                27 : [function(_dereq_, module, exports) {
                    module.exports = after;
                    function after(count, callback, err_cb) {
                        var bail = false;
                        err_cb = err_cb || noop;
                        proxy.count = count;
                        return count === 0 ? callback() : proxy;
                        function proxy(err, result) {
                            if (proxy.count <= 0) {
                                throw new Error("after called too many times")
                            }--proxy.count;
                            if (err) {
                                bail = true;
                                callback(err);
                                callback = err_cb
                            } else if (proxy.count === 0 && !bail) {
                                callback(null, result)
                            }
                        }
                    }
                    function noop() {}
                },
                    {}],
                28 : [function(_dereq_, module, exports) {
                    module.exports = function(arraybuffer, start, end) {
                        var bytes = arraybuffer.byteLength;
                        start = start || 0;
                        end = end || bytes;
                        if (arraybuffer.slice) {
                            return arraybuffer.slice(start, end)
                        }
                        if (start < 0) {
                            start += bytes
                        }
                        if (end < 0) {
                            end += bytes
                        }
                        if (end > bytes) {
                            end = bytes
                        }
                        if (start >= bytes || start >= end || bytes === 0) {
                            return new ArrayBuffer(0)
                        }
                        var abv = new Uint8Array(arraybuffer);
                        var result = new Uint8Array(end - start);
                        for (var i = start,
                                 ii = 0; i < end; i++, ii++) {
                            result[ii] = abv[i]
                        }
                        return result.buffer
                    }
                },
                    {}],
                29 : [function(_dereq_, module, exports) { (function(chars) {
                    "use strict";
                    exports.encode = function(arraybuffer) {
                        var bytes = new Uint8Array(arraybuffer),
                            i,
                            len = bytes.length,
                            base64 = "";
                        for (i = 0; i < len; i += 3) {
                            base64 += chars[bytes[i] >> 2];
                            base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
                            base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
                            base64 += chars[bytes[i + 2] & 63]
                        }
                        if (len % 3 === 2) {
                            base64 = base64.substring(0, base64.length - 1) + "="
                        } else if (len % 3 === 1) {
                            base64 = base64.substring(0, base64.length - 2) + "=="
                        }
                        return base64
                    };
                    exports.decode = function(base64) {
                        var bufferLength = base64.length * .75,
                            len = base64.length,
                            i, p = 0,
                            encoded1, encoded2, encoded3, encoded4;
                        if (base64[base64.length - 1] === "=") {
                            bufferLength--;
                            if (base64[base64.length - 2] === "=") {
                                bufferLength--
                            }
                        }
                        var arraybuffer = new ArrayBuffer(bufferLength),
                            bytes = new Uint8Array(arraybuffer);
                        for (i = 0; i < len; i += 4) {
                            encoded1 = chars.indexOf(base64[i]);
                            encoded2 = chars.indexOf(base64[i + 1]);
                            encoded3 = chars.indexOf(base64[i + 2]);
                            encoded4 = chars.indexOf(base64[i + 3]);
                            bytes[p++] = encoded1 << 2 | encoded2 >> 4;
                            bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
                            bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63
                        }
                        return arraybuffer
                    }
                })("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
                },
                    {}],
                30 : [function(_dereq_, module, exports) { (function(global) {
                    var BlobBuilder = global.BlobBuilder || global.WebKitBlobBuilder || global.MSBlobBuilder || global.MozBlobBuilder;
                    var blobSupported = function() {
                        try {
                            var b = new Blob(["hi"]);
                            return b.size == 2
                        } catch(e) {
                            return false
                        }
                    } ();
                    var blobBuilderSupported = BlobBuilder && BlobBuilder.prototype.append && BlobBuilder.prototype.getBlob;
                    function BlobBuilderConstructor(ary, options) {
                        options = options || {};
                        var bb = new BlobBuilder;
                        for (var i = 0; i < ary.length; i++) {
                            bb.append(ary[i])
                        }
                        return options.type ? bb.getBlob(options.type) : bb.getBlob()
                    }
                    module.exports = function() {
                        if (blobSupported) {
                            return global.Blob
                        } else if (blobBuilderSupported) {
                            return BlobBuilderConstructor
                        } else {
                            return undefined
                        }
                    } ()
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {}],
                31 : [function(_dereq_, module, exports) { (function(global) {
                    var isArray = _dereq_("isarray");
                    module.exports = hasBinary;
                    function hasBinary(data) {
                        function _hasBinary(obj) {
                            if (!obj) return false;
                            if (global.Buffer && global.Buffer.isBuffer(obj) || global.ArrayBuffer && obj instanceof ArrayBuffer || global.Blob && obj instanceof Blob || global.File && obj instanceof File) {
                                return true
                            }
                            if (isArray(obj)) {
                                for (var i = 0; i < obj.length; i++) {
                                    if (_hasBinary(obj[i])) {
                                        return true
                                    }
                                }
                            } else if (obj && "object" == typeof obj) {
                                if (obj.toJSON) {
                                    obj = obj.toJSON()
                                }
                                for (var key in obj) {
                                    if (obj.hasOwnProperty(key) && _hasBinary(obj[key])) {
                                        return true
                                    }
                                }
                            }
                            return false
                        }
                        return _hasBinary(data)
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        isarray: 32
                    }],
                32 : [function(_dereq_, module, exports) {
                    module.exports = Array.isArray ||
                        function(arr) {
                            return Object.prototype.toString.call(arr) == "[object Array]"
                        }
                },
                    {}],
                33 : [function(_dereq_, module, exports) { (function(global) { (function(root) {
                    var freeExports = typeof exports == "object" && exports;
                    var freeModule = typeof module == "object" && module && module.exports == freeExports && module;
                    var freeGlobal = typeof global == "object" && global;
                    if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
                        root = freeGlobal
                    }
                    var stringFromCharCode = String.fromCharCode;
                    function ucs2decode(string) {
                        var output = [];
                        var counter = 0;
                        var length = string.length;
                        var value;
                        var extra;
                        while (counter < length) {
                            value = string.charCodeAt(counter++);
                            if (value >= 55296 && value <= 56319 && counter < length) {
                                extra = string.charCodeAt(counter++);
                                if ((extra & 64512) == 56320) {
                                    output.push(((value & 1023) << 10) + (extra & 1023) + 65536)
                                } else {
                                    output.push(value);
                                    counter--
                                }
                            } else {
                                output.push(value)
                            }
                        }
                        return output
                    }
                    function ucs2encode(array) {
                        var length = array.length;
                        var index = -1;
                        var value;
                        var output = "";
                        while (++index < length) {
                            value = array[index];
                            if (value > 65535) {
                                value -= 65536;
                                output += stringFromCharCode(value >>> 10 & 1023 | 55296);
                                value = 56320 | value & 1023
                            }
                            output += stringFromCharCode(value)
                        }
                        return output
                    }
                    function createByte(codePoint, shift) {
                        return stringFromCharCode(codePoint >> shift & 63 | 128)
                    }
                    function encodeCodePoint(codePoint) {
                        if ((codePoint & 4294967168) == 0) {
                            return stringFromCharCode(codePoint)
                        }
                        var symbol = "";
                        if ((codePoint & 4294965248) == 0) {
                            symbol = stringFromCharCode(codePoint >> 6 & 31 | 192)
                        } else if ((codePoint & 4294901760) == 0) {
                            symbol = stringFromCharCode(codePoint >> 12 & 15 | 224);
                            symbol += createByte(codePoint, 6)
                        } else if ((codePoint & 4292870144) == 0) {
                            symbol = stringFromCharCode(codePoint >> 18 & 7 | 240);
                            symbol += createByte(codePoint, 12);
                            symbol += createByte(codePoint, 6)
                        }
                        symbol += stringFromCharCode(codePoint & 63 | 128);
                        return symbol
                    }
                    function utf8encode(string) {
                        var codePoints = ucs2decode(string);
                        var length = codePoints.length;
                        var index = -1;
                        var codePoint;
                        var byteString = "";
                        while (++index < length) {
                            codePoint = codePoints[index];
                            byteString += encodeCodePoint(codePoint)
                        }
                        return byteString
                    }
                    function readContinuationByte() {
                        if (byteIndex >= byteCount) {
                            throw Error("Invalid byte index")
                        }
                        var continuationByte = byteArray[byteIndex] & 255;
                        byteIndex++;
                        if ((continuationByte & 192) == 128) {
                            return continuationByte & 63
                        }
                        throw Error("Invalid continuation byte")
                    }
                    function decodeSymbol() {
                        var byte1;
                        var byte2;
                        var byte3;
                        var byte4;
                        var codePoint;
                        if (byteIndex > byteCount) {
                            throw Error("Invalid byte index")
                        }
                        if (byteIndex == byteCount) {
                            return false
                        }
                        byte1 = byteArray[byteIndex] & 255;
                        byteIndex++;
                        if ((byte1 & 128) == 0) {
                            return byte1
                        }
                        if ((byte1 & 224) == 192) {
                            var byte2 = readContinuationByte();
                            codePoint = (byte1 & 31) << 6 | byte2;
                            if (codePoint >= 128) {
                                return codePoint
                            } else {
                                throw Error("Invalid continuation byte")
                            }
                        }
                        if ((byte1 & 240) == 224) {
                            byte2 = readContinuationByte();
                            byte3 = readContinuationByte();
                            codePoint = (byte1 & 15) << 12 | byte2 << 6 | byte3;
                            if (codePoint >= 2048) {
                                return codePoint
                            } else {
                                throw Error("Invalid continuation byte")
                            }
                        }
                        if ((byte1 & 248) == 240) {
                            byte2 = readContinuationByte();
                            byte3 = readContinuationByte();
                            byte4 = readContinuationByte();
                            codePoint = (byte1 & 15) << 18 | byte2 << 12 | byte3 << 6 | byte4;
                            if (codePoint >= 65536 && codePoint <= 1114111) {
                                return codePoint
                            }
                        }
                        throw Error("Invalid UTF-8 detected")
                    }
                    var byteArray;
                    var byteCount;
                    var byteIndex;
                    function utf8decode(byteString) {
                        byteArray = ucs2decode(byteString);
                        byteCount = byteArray.length;
                        byteIndex = 0;
                        var codePoints = [];
                        var tmp;
                        while ((tmp = decodeSymbol()) !== false) {
                            codePoints.push(tmp)
                        }
                        return ucs2encode(codePoints)
                    }
                    var utf8 = {
                        version: "2.0.0",
                        encode: utf8encode,
                        decode: utf8decode
                    };
                    if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
                        define(function() {
                            return utf8
                        })
                    } else if (freeExports && !freeExports.nodeType) {
                        if (freeModule) {
                            freeModule.exports = utf8
                        } else {
                            var object = {};
                            var hasOwnProperty = object.hasOwnProperty;
                            for (var key in utf8) {
                                hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key])
                            }
                        }
                    } else {
                        root.utf8 = utf8
                    }
                })(this)
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {}],
                34 : [function(_dereq_, module, exports) { (function(global) {
                    var rvalidchars = /^[\],:{}\s]*$/;
                    var rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
                    var rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
                    var rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g;
                    var rtrimLeft = /^\s+/;
                    var rtrimRight = /\s+$/;
                    module.exports = function parsejson(data) {
                        if ("string" != typeof data || !data) {
                            return null
                        }
                        data = data.replace(rtrimLeft, "").replace(rtrimRight, "");
                        if (global.JSON && JSON.parse) {
                            return JSON.parse(data)
                        }
                        if (rvalidchars.test(data.replace(rvalidescape, "@").replace(rvalidtokens, "]").replace(rvalidbraces, ""))) {
                            return new Function("return " + data)()
                        }
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {}],
                35 : [function(_dereq_, module, exports) {
                    exports.encode = function(obj) {
                        var str = "";
                        for (var i in obj) {
                            if (obj.hasOwnProperty(i)) {
                                if (str.length) str += "&";
                                str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i])
                            }
                        }
                        return str
                    };
                    exports.decode = function(qs) {
                        var qry = {};
                        var pairs = qs.split("&");
                        for (var i = 0,
                                 l = pairs.length; i < l; i++) {
                            var pair = pairs[i].split("=");
                            qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1])
                        }
                        return qry
                    }
                },
                    {}],
                36 : [function(_dereq_, module, exports) {
                    var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
                    var parts = ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"];
                    module.exports = function parseuri(str) {
                        var src = str,
                            b = str.indexOf("["),
                            e = str.indexOf("]");
                        if (b != -1 && e != -1) {
                            str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length)
                        }
                        var m = re.exec(str || ""),
                            uri = {},
                            i = 14;
                        while (i--) {
                            uri[parts[i]] = m[i] || ""
                        }
                        if (b != -1 && e != -1) {
                            uri.source = src;
                            uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":");
                            uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":");
                            uri.ipv6uri = true
                        }
                        return uri
                    }
                },
                    {}],
                37 : [function(_dereq_, module, exports) {
                    var global = function() {
                        return this
                    } ();
                    var WebSocket = global.WebSocket || global.MozWebSocket;
                    module.exports = WebSocket ? ws: null;
                    function ws(uri, protocols, opts) {
                        var instance;
                        if (protocols) {
                            instance = new WebSocket(uri, protocols)
                        } else {
                            instance = new WebSocket(uri)
                        }
                        return instance
                    }
                    if (WebSocket) ws.prototype = WebSocket.prototype
                },
                    {}],
                38 : [function(_dereq_, module, exports) { (function(global) {
                    var isArray = _dereq_("isarray");
                    module.exports = hasBinary;
                    function hasBinary(data) {
                        function _hasBinary(obj) {
                            if (!obj) return false;
                            if (global.Buffer && global.Buffer.isBuffer(obj) || global.ArrayBuffer && obj instanceof ArrayBuffer || global.Blob && obj instanceof Blob || global.File && obj instanceof File) {
                                return true
                            }
                            if (isArray(obj)) {
                                for (var i = 0; i < obj.length; i++) {
                                    if (_hasBinary(obj[i])) {
                                        return true
                                    }
                                }
                            } else if (obj && "object" == typeof obj) {
                                if (obj.toJSON) {
                                    obj = obj.toJSON()
                                }
                                for (var key in obj) {
                                    if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
                                        return true
                                    }
                                }
                            }
                            return false
                        }
                        return _hasBinary(data)
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        isarray: 39
                    }],
                39 : [function(_dereq_, module, exports) {
                    module.exports = _dereq_(32)
                },
                    {}],
                40 : [function(_dereq_, module, exports) {
                    var global = _dereq_("global");
                    try {
                        module.exports = "XMLHttpRequest" in global && "withCredentials" in new global.XMLHttpRequest
                    } catch(err) {
                        module.exports = false
                    }
                },
                    {
                        global: 41
                    }],
                41 : [function(_dereq_, module, exports) {
                    module.exports = function() {
                        return this
                    } ()
                },
                    {}],
                42 : [function(_dereq_, module, exports) {
                    var indexOf = [].indexOf;
                    module.exports = function(arr, obj) {
                        if (indexOf) return arr.indexOf(obj);
                        for (var i = 0; i < arr.length; ++i) {
                            if (arr[i] === obj) return i
                        }
                        return - 1
                    }
                },
                    {}],
                43 : [function(_dereq_, module, exports) {
                    var has = Object.prototype.hasOwnProperty;
                    exports.keys = Object.keys ||
                        function(obj) {
                            var keys = [];
                            for (var key in obj) {
                                if (has.call(obj, key)) {
                                    keys.push(key)
                                }
                            }
                            return keys
                        };
                    exports.values = function(obj) {
                        var vals = [];
                        for (var key in obj) {
                            if (has.call(obj, key)) {
                                vals.push(obj[key])
                            }
                        }
                        return vals
                    };
                    exports.merge = function(a, b) {
                        for (var key in b) {
                            if (has.call(b, key)) {
                                a[key] = b[key]
                            }
                        }
                        return a
                    };
                    exports.length = function(obj) {
                        return exports.keys(obj).length
                    };
                    exports.isEmpty = function(obj) {
                        return 0 == exports.length(obj)
                    }
                },
                    {}],
                44 : [function(_dereq_, module, exports) {
                    var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
                    var parts = ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"];
                    module.exports = function parseuri(str) {
                        var m = re.exec(str || ""),
                            uri = {},
                            i = 14;
                        while (i--) {
                            uri[parts[i]] = m[i] || ""
                        }
                        return uri
                    }
                },
                    {}],
                45 : [function(_dereq_, module, exports) { (function(global) {
                    var isArray = _dereq_("isarray");
                    var isBuf = _dereq_("./is-buffer");
                    exports.deconstructPacket = function(packet) {
                        var buffers = [];
                        var packetData = packet.data;
                        function _deconstructPacket(data) {
                            if (!data) return data;
                            if (isBuf(data)) {
                                var placeholder = {
                                    _placeholder: true,
                                    num: buffers.length
                                };
                                buffers.push(data);
                                return placeholder
                            } else if (isArray(data)) {
                                var newData = new Array(data.length);
                                for (var i = 0; i < data.length; i++) {
                                    newData[i] = _deconstructPacket(data[i])
                                }
                                return newData
                            } else if ("object" == typeof data && !(data instanceof Date)) {
                                var newData = {};
                                for (var key in data) {
                                    newData[key] = _deconstructPacket(data[key])
                                }
                                return newData
                            }
                            return data
                        }
                        var pack = packet;
                        pack.data = _deconstructPacket(packetData);
                        pack.attachments = buffers.length;
                        return {
                            packet: pack,
                            buffers: buffers
                        }
                    };
                    exports.reconstructPacket = function(packet, buffers) {
                        var curPlaceHolder = 0;
                        function _reconstructPacket(data) {
                            if (data && data._placeholder) {
                                var buf = buffers[data.num];
                                return buf
                            } else if (isArray(data)) {
                                for (var i = 0; i < data.length; i++) {
                                    data[i] = _reconstructPacket(data[i])
                                }
                                return data
                            } else if (data && "object" == typeof data) {
                                for (var key in data) {
                                    data[key] = _reconstructPacket(data[key])
                                }
                                return data
                            }
                            return data
                        }
                        packet.data = _reconstructPacket(packet.data);
                        packet.attachments = undefined;
                        return packet
                    };
                    exports.removeBlobs = function(data, callback) {
                        function _removeBlobs(obj, curKey, containingObject) {
                            if (!obj) return obj;
                            if (global.Blob && obj instanceof Blob || global.File && obj instanceof File) {
                                pendingBlobs++;
                                var fileReader = new FileReader;
                                fileReader.onload = function() {
                                    if (containingObject) {
                                        containingObject[curKey] = this.result
                                    } else {
                                        bloblessData = this.result
                                    }
                                    if (!--pendingBlobs) {
                                        callback(bloblessData)
                                    }
                                };
                                fileReader.readAsArrayBuffer(obj)
                            } else if (isArray(obj)) {
                                for (var i = 0; i < obj.length; i++) {
                                    _removeBlobs(obj[i], i, obj)
                                }
                            } else if (obj && "object" == typeof obj && !isBuf(obj)) {
                                for (var key in obj) {
                                    _removeBlobs(obj[key], key, obj)
                                }
                            }
                        }
                        var pendingBlobs = 0;
                        var bloblessData = data;
                        _removeBlobs(bloblessData);
                        if (!pendingBlobs) {
                            callback(bloblessData)
                        }
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {
                        "./is-buffer": 47,
                        isarray: 48
                    }],
                46 : [function(_dereq_, module, exports) {
                    var debug = _dereq_("debug")("socket.io-parser");
                    var json = _dereq_("json3");
                    var isArray = _dereq_("isarray");
                    var Emitter = _dereq_("component-emitter");
                    var binary = _dereq_("./binary");
                    var isBuf = _dereq_("./is-buffer");
                    exports.protocol = 4;
                    exports.types = ["CONNECT", "DISCONNECT", "EVENT", "BINARY_EVENT", "ACK", "BINARY_ACK", "ERROR"];
                    exports.CONNECT = 0;
                    exports.DISCONNECT = 1;
                    exports.EVENT = 2;
                    exports.ACK = 3;
                    exports.ERROR = 4;
                    exports.BINARY_EVENT = 5;
                    exports.BINARY_ACK = 6;
                    exports.Encoder = Encoder;
                    exports.Decoder = Decoder;
                    function Encoder() {}
                    Encoder.prototype.encode = function(obj, callback) {
                        debug("encoding packet %j", obj);
                        if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
                            encodeAsBinary(obj, callback)
                        } else {
                            var encoding = encodeAsString(obj);
                            callback([encoding])
                        }
                    };
                    function encodeAsString(obj) {
                        var str = "";
                        var nsp = false;
                        str += obj.type;
                        if (exports.BINARY_EVENT == obj.type || exports.BINARY_ACK == obj.type) {
                            str += obj.attachments;
                            str += "-"
                        }
                        if (obj.nsp && "/" != obj.nsp) {
                            nsp = true;
                            str += obj.nsp
                        }
                        if (null != obj.id) {
                            if (nsp) {
                                str += ",";
                                nsp = false
                            }
                            str += obj.id
                        }
                        if (null != obj.data) {
                            if (nsp) str += ",";
                            str += json.stringify(obj.data)
                        }
                        debug("encoded %j as %s", obj, str);
                        return str
                    }
                    function encodeAsBinary(obj, callback) {
                        function writeEncoding(bloblessData) {
                            var deconstruction = binary.deconstructPacket(bloblessData);
                            var pack = encodeAsString(deconstruction.packet);
                            var buffers = deconstruction.buffers;
                            buffers.unshift(pack);
                            callback(buffers)
                        }
                        binary.removeBlobs(obj, writeEncoding)
                    }
                    function Decoder() {
                        this.reconstructor = null
                    }
                    Emitter(Decoder.prototype);
                    Decoder.prototype.add = function(obj) {
                        var packet;
                        if ("string" == typeof obj) {
                            packet = decodeString(obj);
                            if (exports.BINARY_EVENT == packet.type || exports.BINARY_ACK == packet.type) {
                                this.reconstructor = new BinaryReconstructor(packet);
                                if (this.reconstructor.reconPack.attachments === 0) {
                                    this.emit("decoded", packet)
                                }
                            } else {
                                this.emit("decoded", packet)
                            }
                        } else if (isBuf(obj) || obj.base64) {
                            if (!this.reconstructor) {
                                throw new Error("got binary data when not reconstructing a packet")
                            } else {
                                packet = this.reconstructor.takeBinaryData(obj);
                                if (packet) {
                                    this.reconstructor = null;
                                    this.emit("decoded", packet)
                                }
                            }
                        } else {
                            throw new Error("Unknown type: " + obj)
                        }
                    };
                    function decodeString(str) {
                        var p = {};
                        var i = 0;
                        p.type = Number(str.charAt(0));
                        if (null == exports.types[p.type]) return error();
                        if (exports.BINARY_EVENT == p.type || exports.BINARY_ACK == p.type) {
                            var buf = "";
                            while (str.charAt(++i) != "-") {
                                buf += str.charAt(i);
                                if (i + 1 == str.length) break
                            }
                            if (buf != Number(buf) || str.charAt(i) != "-") {
                                throw new Error("Illegal attachments")
                            }
                            p.attachments = Number(buf)
                        }
                        if ("/" == str.charAt(i + 1)) {
                            p.nsp = "";
                            while (++i) {
                                var c = str.charAt(i);
                                if ("," == c) break;
                                p.nsp += c;
                                if (i + 1 == str.length) break
                            }
                        } else {
                            p.nsp = "/"
                        }
                        var next = str.charAt(i + 1);
                        if ("" !== next && Number(next) == next) {
                            p.id = "";
                            while (++i) {
                                var c = str.charAt(i);
                                if (null == c || Number(c) != c) {--i;
                                    break
                                }
                                p.id += str.charAt(i);
                                if (i + 1 == str.length) break
                            }
                            p.id = Number(p.id)
                        }
                        if (str.charAt(++i)) {
                            try {
                                p.data = json.parse(str.substr(i))
                            } catch(e) {
                                return error()
                            }
                        }
                        debug("decoded %s as %j", str, p);
                        return p
                    }
                    Decoder.prototype.destroy = function() {
                        if (this.reconstructor) {
                            this.reconstructor.finishedReconstruction()
                        }
                    };
                    function BinaryReconstructor(packet) {
                        this.reconPack = packet;
                        this.buffers = []
                    }
                    BinaryReconstructor.prototype.takeBinaryData = function(binData) {
                        this.buffers.push(binData);
                        if (this.buffers.length == this.reconPack.attachments) {
                            var packet = binary.reconstructPacket(this.reconPack, this.buffers);
                            this.finishedReconstruction();
                            return packet
                        }
                        return null
                    };
                    BinaryReconstructor.prototype.finishedReconstruction = function() {
                        this.reconPack = null;
                        this.buffers = []
                    };
                    function error(data) {
                        return {
                            type: exports.ERROR,
                            data: "parser error"
                        }
                    }
                },
                    {
                        "./binary": 45,
                        "./is-buffer": 47,
                        "component-emitter": 9,
                        debug: 10,
                        isarray: 48,
                        json3: 49
                    }],
                47 : [function(_dereq_, module, exports) { (function(global) {
                    module.exports = isBuf;
                    function isBuf(obj) {
                        return global.Buffer && global.Buffer.isBuffer(obj) || global.ArrayBuffer && obj instanceof ArrayBuffer
                    }
                }).call(this, typeof self !== "undefined" ? self: typeof window !== "undefined" ? window: {})
                },
                    {}],
                48 : [function(_dereq_, module, exports) {
                    module.exports = _dereq_(32)
                },
                    {}],
                49 : [function(_dereq_, module, exports) { (function(window) {
                    var getClass = {}.toString,
                        isProperty, forEach, undef;
                    var isLoader = typeof define === "function" && define.amd;
                    var nativeJSON = typeof JSON == "object" && JSON;
                    var JSON3 = typeof exports == "object" && exports && !exports.nodeType && exports;
                    if (JSON3 && nativeJSON) {
                        JSON3.stringify = nativeJSON.stringify;
                        JSON3.parse = nativeJSON.parse
                    } else {
                        JSON3 = window.JSON = nativeJSON || {}
                    }
                    var isExtended = new Date( - 0xc782b5b800cec);
                    try {
                        isExtended = isExtended.getUTCFullYear() == -109252 && isExtended.getUTCMonth() === 0 && isExtended.getUTCDate() === 1 && isExtended.getUTCHours() == 10 && isExtended.getUTCMinutes() == 37 && isExtended.getUTCSeconds() == 6 && isExtended.getUTCMilliseconds() == 708
                    } catch(exception) {}
                    function has(name) {
                        if (has[name] !== undef) {
                            return has[name]
                        }
                        var isSupported;
                        if (name == "bug-string-char-index") {
                            isSupported = "a" [0] != "a"
                        } else if (name == "json") {
                            isSupported = has("json-stringify") && has("json-parse")
                        } else {
                            var value, serialized = '{"a":[1,true,false,null,"\\u0000\\b\\n\\f\\r\\t"]}';
                            if (name == "json-stringify") {
                                var stringify = JSON3.stringify,
                                    stringifySupported = typeof stringify == "function" && isExtended;
                                if (stringifySupported) { (value = function() {
                                    return 1
                                }).toJSON = value;
                                    try {
                                        stringifySupported = stringify(0) === "0" && stringify(new Number) === "0" && stringify(new String) == '""' && stringify(getClass) === undef && stringify(undef) === undef && stringify() === undef && stringify(value) === "1" && stringify([value]) == "[1]" && stringify([undef]) == "[null]" && stringify(null) == "null" && stringify([undef, getClass, null]) == "[null,null,null]" && stringify({
                                                a: [value, true, false, null, "\x00\b\n\f\r	"]
                                            }) == serialized && stringify(null, value) === "1" && stringify([1, 2], null, 1) == "[\n 1,\n 2\n]" && stringify(new Date( - 864e13)) == '"-271821-04-20T00:00:00.000Z"' && stringify(new Date(864e13)) == '"+275760-09-13T00:00:00.000Z"' && stringify(new Date( - 621987552e5)) == '"-000001-01-01T00:00:00.000Z"' && stringify(new Date( - 1)) == '"1969-12-31T23:59:59.999Z"'
                                    } catch(exception) {
                                        stringifySupported = false
                                    }
                                }
                                isSupported = stringifySupported
                            }
                            if (name == "json-parse") {
                                var parse = JSON3.parse;
                                if (typeof parse == "function") {
                                    try {
                                        if (parse("0") === 0 && !parse(false)) {
                                            value = parse(serialized);
                                            var parseSupported = value["a"].length == 5 && value["a"][0] === 1;
                                            if (parseSupported) {
                                                try {
                                                    parseSupported = !parse('"	"')
                                                } catch(exception) {}
                                                if (parseSupported) {
                                                    try {
                                                        parseSupported = parse("01") !== 1
                                                    } catch(exception) {}
                                                }
                                                if (parseSupported) {
                                                    try {
                                                        parseSupported = parse("1.") !== 1
                                                    } catch(exception) {}
                                                }
                                            }
                                        }
                                    } catch(exception) {
                                        parseSupported = false
                                    }
                                }
                                isSupported = parseSupported
                            }
                        }
                        return has[name] = !!isSupported
                    }
                    if (!has("json")) {
                        var functionClass = "[object Function]";
                        var dateClass = "[object Date]";
                        var numberClass = "[object Number]";
                        var stringClass = "[object String]";
                        var arrayClass = "[object Array]";
                        var booleanClass = "[object Boolean]";
                        var charIndexBuggy = has("bug-string-char-index");
                        if (!isExtended) {
                            var floor = Math.floor;
                            var Months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
                            var getDay = function(year, month) {
                                return Months[month] + 365 * (year - 1970) + floor((year - 1969 + (month = +(month > 1))) / 4) - floor((year - 1901 + month) / 100) + floor((year - 1601 + month) / 400)
                            }
                        }
                        if (! (isProperty = {}.hasOwnProperty)) {
                            isProperty = function(property) {
                                var members = {},
                                    constructor;
                                if ((members.__proto__ = null, members.__proto__ = {
                                        toString: 1
                                    },
                                        members).toString != getClass) {
                                    isProperty = function(property) {
                                        var original = this.__proto__,
                                            result = property in (this.__proto__ = null, this);
                                        this.__proto__ = original;
                                        return result
                                    }
                                } else {
                                    constructor = members.constructor;
                                    isProperty = function(property) {
                                        var parent = (this.constructor || constructor).prototype;
                                        return property in this && !(property in parent && this[property] === parent[property])
                                    }
                                }
                                members = null;
                                return isProperty.call(this, property)
                            }
                        }
                        var PrimitiveTypes = {
                            "boolean": 1,
                            number: 1,
                            string: 1,
                            undefined: 1
                        };
                        var isHostType = function(object, property) {
                            var type = typeof object[property];
                            return type == "object" ? !!object[property] : !PrimitiveTypes[type]
                        };
                        forEach = function(object, callback) {
                            var size = 0,
                                Properties, members, property; (Properties = function() {
                                this.valueOf = 0
                            }).prototype.valueOf = 0;
                            members = new Properties;
                            for (property in members) {
                                if (isProperty.call(members, property)) {
                                    size++
                                }
                            }
                            Properties = members = null;
                            if (!size) {
                                members = ["valueOf", "toString", "toLocaleString", "propertyIsEnumerable", "isPrototypeOf", "hasOwnProperty", "constructor"];
                                forEach = function(object, callback) {
                                    var isFunction = getClass.call(object) == functionClass,
                                        property,
                                        length;
                                    var hasProperty = !isFunction && typeof object.constructor != "function" && isHostType(object, "hasOwnProperty") ? object.hasOwnProperty: isProperty;
                                    for (property in object) {
                                        if (! (isFunction && property == "prototype") && hasProperty.call(object, property)) {
                                            callback(property)
                                        }
                                    }
                                    for (length = members.length; property = members[--length]; hasProperty.call(object, property) && callback(property));
                                }
                            } else if (size == 2) {
                                forEach = function(object, callback) {
                                    var members = {},
                                        isFunction = getClass.call(object) == functionClass,
                                        property;
                                    for (property in object) {
                                        if (! (isFunction && property == "prototype") && !isProperty.call(members, property) && (members[property] = 1) && isProperty.call(object, property)) {
                                            callback(property)
                                        }
                                    }
                                }
                            } else {
                                forEach = function(object, callback) {
                                    var isFunction = getClass.call(object) == functionClass,
                                        property,
                                        isConstructor;
                                    for (property in object) {
                                        if (! (isFunction && property == "prototype") && isProperty.call(object, property) && !(isConstructor = property === "constructor")) {
                                            callback(property)
                                        }
                                    }
                                    if (isConstructor || isProperty.call(object, property = "constructor")) {
                                        callback(property)
                                    }
                                }
                            }
                            return forEach(object, callback)
                        };
                        if (!has("json-stringify")) {
                            var Escapes = {
                                92 : "\\\\",
                                34 : '\\"',
                                8 : "\\b",
                                12 : "\\f",
                                10 : "\\n",
                                13 : "\\r",
                                9 : "\\t"
                            };
                            var leadingZeroes = "000000";
                            var toPaddedString = function(width, value) {
                                return (leadingZeroes + (value || 0)).slice( - width)
                            };
                            var unicodePrefix = "\\u00";
                            var quote = function(value) {
                                var result = '"',
                                    index = 0,
                                    length = value.length,
                                    isLarge = length > 10 && charIndexBuggy,
                                    symbols;
                                if (isLarge) {
                                    symbols = value.split("")
                                }
                                for (; index < length; index++) {
                                    var charCode = value.charCodeAt(index);
                                    switch (charCode) {
                                        case 8:
                                        case 9:
                                        case 10:
                                        case 12:
                                        case 13:
                                        case 34:
                                        case 92:
                                            result += Escapes[charCode];
                                            break;
                                        default:
                                            if (charCode < 32) {
                                                result += unicodePrefix + toPaddedString(2, charCode.toString(16));
                                                break
                                            }
                                            result += isLarge ? symbols[index] : charIndexBuggy ? value.charAt(index) : value[index]
                                    }
                                }
                                return result + '"'
                            };
                            var serialize = function(property, object, callback, properties, whitespace, indentation, stack) {
                                var value, className, year, month, date, time, hours, minutes, seconds, milliseconds, results, element, index, length, prefix, result;
                                try {
                                    value = object[property]
                                } catch(exception) {}
                                if (typeof value == "object" && value) {
                                    className = getClass.call(value);
                                    if (className == dateClass && !isProperty.call(value, "toJSON")) {
                                        if (value > -1 / 0 && value < 1 / 0) {
                                            if (getDay) {
                                                date = floor(value / 864e5);
                                                for (year = floor(date / 365.2425) + 1970 - 1; getDay(year + 1, 0) <= date; year++);
                                                for (month = floor((date - getDay(year, 0)) / 30.42); getDay(year, month + 1) <= date; month++);
                                                date = 1 + date - getDay(year, month);
                                                time = (value % 864e5 + 864e5) % 864e5;
                                                hours = floor(time / 36e5) % 24;
                                                minutes = floor(time / 6e4) % 60;
                                                seconds = floor(time / 1e3) % 60;
                                                milliseconds = time % 1e3
                                            } else {
                                                year = value.getUTCFullYear();
                                                month = value.getUTCMonth();
                                                date = value.getUTCDate();
                                                hours = value.getUTCHours();
                                                minutes = value.getUTCMinutes();
                                                seconds = value.getUTCSeconds();
                                                milliseconds = value.getUTCMilliseconds()
                                            }
                                            value = (year <= 0 || year >= 1e4 ? (year < 0 ? "-": "+") + toPaddedString(6, year < 0 ? -year: year) : toPaddedString(4, year)) + "-" + toPaddedString(2, month + 1) + "-" + toPaddedString(2, date) + "T" + toPaddedString(2, hours) + ":" + toPaddedString(2, minutes) + ":" + toPaddedString(2, seconds) + "." + toPaddedString(3, milliseconds) + "Z"
                                        } else {
                                            value = null
                                        }
                                    } else if (typeof value.toJSON == "function" && (className != numberClass && className != stringClass && className != arrayClass || isProperty.call(value, "toJSON"))) {
                                        value = value.toJSON(property)
                                    }
                                }
                                if (callback) {
                                    value = callback.call(object, property, value)
                                }
                                if (value === null) {
                                    return "null"
                                }
                                className = getClass.call(value);
                                if (className == booleanClass) {
                                    return "" + value
                                } else if (className == numberClass) {
                                    return value > -1 / 0 && value < 1 / 0 ? "" + value: "null"
                                } else if (className == stringClass) {
                                    return quote("" + value)
                                }
                                if (typeof value == "object") {
                                    for (length = stack.length; length--;) {
                                        if (stack[length] === value) {
                                            throw TypeError()
                                        }
                                    }
                                    stack.push(value);
                                    results = [];
                                    prefix = indentation;
                                    indentation += whitespace;
                                    if (className == arrayClass) {
                                        for (index = 0, length = value.length; index < length; index++) {
                                            element = serialize(index, value, callback, properties, whitespace, indentation, stack);
                                            results.push(element === undef ? "null": element)
                                        }
                                        result = results.length ? whitespace ? "[\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "]": "[" + results.join(",") + "]": "[]"
                                    } else {
                                        forEach(properties || value,
                                            function(property) {
                                                var element = serialize(property, value, callback, properties, whitespace, indentation, stack);
                                                if (element !== undef) {
                                                    results.push(quote(property) + ":" + (whitespace ? " ": "") + element)
                                                }
                                            });
                                        result = results.length ? whitespace ? "{\n" + indentation + results.join(",\n" + indentation) + "\n" + prefix + "}": "{" + results.join(",") + "}": "{}"
                                    }
                                    stack.pop();
                                    return result
                                }
                            };
                            JSON3.stringify = function(source, filter, width) {
                                var whitespace, callback, properties, className;
                                if (typeof filter == "function" || typeof filter == "object" && filter) {
                                    if ((className = getClass.call(filter)) == functionClass) {
                                        callback = filter
                                    } else if (className == arrayClass) {
                                        properties = {};
                                        for (var index = 0,
                                                 length = filter.length,
                                                 value; index < length; value = filter[index++], (className = getClass.call(value), className == stringClass || className == numberClass) && (properties[value] = 1));
                                    }
                                }
                                if (width) {
                                    if ((className = getClass.call(width)) == numberClass) {
                                        if ((width -= width % 1) > 0) {
                                            for (whitespace = "", width > 10 && (width = 10); whitespace.length < width; whitespace += " ");
                                        }
                                    } else if (className == stringClass) {
                                        whitespace = width.length <= 10 ? width: width.slice(0, 10)
                                    }
                                }
                                return serialize("", (value = {},
                                    value[""] = source, value), callback, properties, whitespace, "", [])
                            }
                        }
                        if (!has("json-parse")) {
                            var fromCharCode = String.fromCharCode;
                            var Unescapes = {
                                92 : "\\",
                                34 : '"',
                                47 : "/",
                                98 : "\b",
                                116 : "	",
                                110 : "\n",
                                102 : "\f",
                                114 : "\r"
                            };
                            var Index, Source;
                            var abort = function() {
                                Index = Source = null;
                                throw SyntaxError()
                            };
                            var lex = function() {
                                var source = Source,
                                    length = source.length,
                                    value, begin, position, isSigned, charCode;
                                while (Index < length) {
                                    charCode = source.charCodeAt(Index);
                                    switch (charCode) {
                                        case 9:
                                        case 10:
                                        case 13:
                                        case 32:
                                            Index++;
                                            break;
                                        case 123:
                                        case 125:
                                        case 91:
                                        case 93:
                                        case 58:
                                        case 44:
                                            value = charIndexBuggy ? source.charAt(Index) : source[Index];
                                            Index++;
                                            return value;
                                        case 34:
                                            for (value = "@", Index++; Index < length;) {
                                                charCode = source.charCodeAt(Index);
                                                if (charCode < 32) {
                                                    abort()
                                                } else if (charCode == 92) {
                                                    charCode = source.charCodeAt(++Index);
                                                    switch (charCode) {
                                                        case 92:
                                                        case 34:
                                                        case 47:
                                                        case 98:
                                                        case 116:
                                                        case 110:
                                                        case 102:
                                                        case 114:
                                                            value += Unescapes[charCode];
                                                            Index++;
                                                            break;
                                                        case 117:
                                                            begin = ++Index;
                                                            for (position = Index + 4; Index < position; Index++) {
                                                                charCode = source.charCodeAt(Index);
                                                                if (! (charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70)) {
                                                                    abort()
                                                                }
                                                            }
                                                            value += fromCharCode("0x" + source.slice(begin, Index));
                                                            break;
                                                        default:
                                                            abort()
                                                    }
                                                } else {
                                                    if (charCode == 34) {
                                                        break
                                                    }
                                                    charCode = source.charCodeAt(Index);
                                                    begin = Index;
                                                    while (charCode >= 32 && charCode != 92 && charCode != 34) {
                                                        charCode = source.charCodeAt(++Index)
                                                    }
                                                    value += source.slice(begin, Index)
                                                }
                                            }
                                            if (source.charCodeAt(Index) == 34) {
                                                Index++;
                                                return value
                                            }
                                            abort();
                                        default:
                                            begin = Index;
                                            if (charCode == 45) {
                                                isSigned = true;
                                                charCode = source.charCodeAt(++Index)
                                            }
                                            if (charCode >= 48 && charCode <= 57) {
                                                if (charCode == 48 && (charCode = source.charCodeAt(Index + 1), charCode >= 48 && charCode <= 57)) {
                                                    abort()
                                                }
                                                isSigned = false;
                                                for (; Index < length && (charCode = source.charCodeAt(Index), charCode >= 48 && charCode <= 57); Index++);
                                                if (source.charCodeAt(Index) == 46) {
                                                    position = ++Index;
                                                    for (; position < length && (charCode = source.charCodeAt(position), charCode >= 48 && charCode <= 57); position++);
                                                    if (position == Index) {
                                                        abort()
                                                    }
                                                    Index = position
                                                }
                                                charCode = source.charCodeAt(Index);
                                                if (charCode == 101 || charCode == 69) {
                                                    charCode = source.charCodeAt(++Index);
                                                    if (charCode == 43 || charCode == 45) {
                                                        Index++
                                                    }
                                                    for (position = Index; position < length && (charCode = source.charCodeAt(position), charCode >= 48 && charCode <= 57); position++);
                                                    if (position == Index) {
                                                        abort()
                                                    }
                                                    Index = position
                                                }
                                                return + source.slice(begin, Index)
                                            }
                                            if (isSigned) {
                                                abort()
                                            }
                                            if (source.slice(Index, Index + 4) == "true") {
                                                Index += 4;
                                                return true
                                            } else if (source.slice(Index, Index + 5) == "false") {
                                                Index += 5;
                                                return false
                                            } else if (source.slice(Index, Index + 4) == "null") {
                                                Index += 4;
                                                return null
                                            }
                                            abort()
                                    }
                                }
                                return "$"
                            };
                            var get = function(value) {
                                var results, hasMembers;
                                if (value == "$") {
                                    abort()
                                }
                                if (typeof value == "string") {
                                    if ((charIndexBuggy ? value.charAt(0) : value[0]) == "@") {
                                        return value.slice(1)
                                    }
                                    if (value == "[") {
                                        results = [];
                                        for (;; hasMembers || (hasMembers = true)) {
                                            value = lex();
                                            if (value == "]") {
                                                break
                                            }
                                            if (hasMembers) {
                                                if (value == ",") {
                                                    value = lex();
                                                    if (value == "]") {
                                                        abort()
                                                    }
                                                } else {
                                                    abort()
                                                }
                                            }
                                            if (value == ",") {
                                                abort()
                                            }
                                            results.push(get(value))
                                        }
                                        return results
                                    } else if (value == "{") {
                                        results = {};
                                        for (;; hasMembers || (hasMembers = true)) {
                                            value = lex();
                                            if (value == "}") {
                                                break
                                            }
                                            if (hasMembers) {
                                                if (value == ",") {
                                                    value = lex();
                                                    if (value == "}") {
                                                        abort()
                                                    }
                                                } else {
                                                    abort()
                                                }
                                            }
                                            if (value == "," || typeof value != "string" || (charIndexBuggy ? value.charAt(0) : value[0]) != "@" || lex() != ":") {
                                                abort()
                                            }
                                            results[value.slice(1)] = get(lex())
                                        }
                                        return results
                                    }
                                    abort()
                                }
                                return value
                            };
                            var update = function(source, property, callback) {
                                var element = walk(source, property, callback);
                                if (element === undef) {
                                    delete source[property]
                                } else {
                                    source[property] = element
                                }
                            };
                            var walk = function(source, property, callback) {
                                var value = source[property],
                                    length;
                                if (typeof value == "object" && value) {
                                    if (getClass.call(value) == arrayClass) {
                                        for (length = value.length; length--;) {
                                            update(value, length, callback)
                                        }
                                    } else {
                                        forEach(value,
                                            function(property) {
                                                update(value, property, callback)
                                            })
                                    }
                                }
                                return callback.call(source, property, value)
                            };
                            JSON3.parse = function(source, callback) {
                                var result, value;
                                Index = 0;
                                Source = "" + source;
                                result = get(lex());
                                if (lex() != "$") {
                                    abort()
                                }
                                Index = Source = null;
                                return callback && getClass.call(callback) == functionClass ? walk((value = {},
                                    value[""] = result, value), "", callback) : result
                            }
                        }
                    }
                    if (isLoader) {
                        define(function() {
                            return JSON3
                        })
                    }
                })(this)
                },
                    {}],
                50 : [function(_dereq_, module, exports) {
                    module.exports = toArray;
                    function toArray(list, index) {
                        var array = [];
                        index = index || 0;
                        for (var i = index || 0; i < list.length; i++) {
                            array[i - index] = list[i]
                        }
                        return array
                    }
                },
                    {}]
            },
            {},
            [1])(1)
    });